aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/cli/internal/cache/cache_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'cli/internal/cache/cache_test.go')
-rw-r--r--cli/internal/cache/cache_test.go318
1 files changed, 0 insertions, 318 deletions
diff --git a/cli/internal/cache/cache_test.go b/cli/internal/cache/cache_test.go
deleted file mode 100644
index 3f17877..0000000
--- a/cli/internal/cache/cache_test.go
+++ /dev/null
@@ -1,318 +0,0 @@
-package cache
-
-import (
- "net/http"
- "reflect"
- "sync/atomic"
- "testing"
-
- "github.com/vercel/turbo/cli/internal/analytics"
- "github.com/vercel/turbo/cli/internal/fs"
- "github.com/vercel/turbo/cli/internal/turbopath"
- "github.com/vercel/turbo/cli/internal/util"
-)
-
-type testCache struct {
- disabledErr *util.CacheDisabledError
- entries map[string][]turbopath.AnchoredSystemPath
-}
-
-func (tc *testCache) Fetch(_ turbopath.AbsoluteSystemPath, hash string, _ []string) (ItemStatus, []turbopath.AnchoredSystemPath, int, error) {
- if tc.disabledErr != nil {
- return ItemStatus{}, nil, 0, tc.disabledErr
- }
- foundFiles, ok := tc.entries[hash]
- if ok {
- duration := 5
- return ItemStatus{Local: true}, foundFiles, duration, nil
- }
- return ItemStatus{}, nil, 0, nil
-}
-
-func (tc *testCache) Exists(hash string) ItemStatus {
- if tc.disabledErr != nil {
- return ItemStatus{}
- }
- _, ok := tc.entries[hash]
- if ok {
- return ItemStatus{Local: true}
- }
- return ItemStatus{}
-}
-
-func (tc *testCache) Put(_ turbopath.AbsoluteSystemPath, hash string, _ int, files []turbopath.AnchoredSystemPath) error {
- if tc.disabledErr != nil {
- return tc.disabledErr
- }
- tc.entries[hash] = files
- return nil
-}
-
-func (tc *testCache) Clean(_ turbopath.AbsoluteSystemPath) {}
-func (tc *testCache) CleanAll() {}
-func (tc *testCache) Shutdown() {}
-
-func newEnabledCache() *testCache {
- return &testCache{
- entries: make(map[string][]turbopath.AnchoredSystemPath),
- }
-}
-
-func newDisabledCache() *testCache {
- return &testCache{
- disabledErr: &util.CacheDisabledError{
- Status: util.CachingStatusDisabled,
- Message: "remote caching is disabled",
- },
- }
-}
-
-func TestPutCachingDisabled(t *testing.T) {
- disabledCache := newDisabledCache()
- caches := []Cache{
- newEnabledCache(),
- disabledCache,
- newEnabledCache(),
- newEnabledCache(),
- }
- var removeCalled uint64
- mplex := &cacheMultiplexer{
- caches: caches,
- onCacheRemoved: func(cache Cache, err error) {
- atomic.AddUint64(&removeCalled, 1)
- },
- }
-
- err := mplex.Put("unused-target", "some-hash", 5, []turbopath.AnchoredSystemPath{"a-file"})
- if err != nil {
- // don't leak the cache removal
- t.Errorf("Put got error %v, want <nil>", err)
- }
-
- removes := atomic.LoadUint64(&removeCalled)
- if removes != 1 {
- t.Errorf("removes count: %v, want 1", removes)
- }
-
- mplex.mu.RLock()
- if len(mplex.caches) != 3 {
- t.Errorf("found %v caches, expected to have 3 after one was removed", len(mplex.caches))
- }
- for _, cache := range mplex.caches {
- if cache == disabledCache {
- t.Error("found disabled cache, expected it to be removed")
- }
- }
- mplex.mu.RUnlock()
-
- // subsequent Fetch should still work
- cacheStatus, _, _, err := mplex.Fetch("unused-target", "some-hash", []string{"unused", "files"})
- if err != nil {
- t.Errorf("got error fetching files: %v", err)
- }
- hit := cacheStatus.Local || cacheStatus.Remote
- if !hit {
- t.Error("failed to find previously stored files")
- }
-
- removes = atomic.LoadUint64(&removeCalled)
- if removes != 1 {
- t.Errorf("removes count: %v, want 1", removes)
- }
-}
-
-func TestExists(t *testing.T) {
- caches := []Cache{
- newEnabledCache(),
- }
-
- mplex := &cacheMultiplexer{
- caches: caches,
- }
-
- itemStatus := mplex.Exists("some-hash")
- if itemStatus.Local {
- t.Error("did not expect file to exist")
- }
-
- err := mplex.Put("unused-target", "some-hash", 5, []turbopath.AnchoredSystemPath{"a-file"})
- if err != nil {
- // don't leak the cache removal
- t.Errorf("Put got error %v, want <nil>", err)
- }
-
- itemStatus = mplex.Exists("some-hash")
- if !itemStatus.Local {
- t.Error("failed to find previously stored files")
- }
-}
-
-type fakeClient struct{}
-
-// FetchArtifact implements client
-func (*fakeClient) FetchArtifact(hash string) (*http.Response, error) {
- panic("unimplemented")
-}
-
-func (*fakeClient) ArtifactExists(hash string) (*http.Response, error) {
- panic("unimplemented")
-}
-
-// GetTeamID implements client
-func (*fakeClient) GetTeamID() string {
- return "fake-team-id"
-}
-
-// PutArtifact implements client
-func (*fakeClient) PutArtifact(hash string, body []byte, duration int, tag string) error {
- panic("unimplemented")
-}
-
-var _ client = &fakeClient{}
-
-func TestFetchCachingDisabled(t *testing.T) {
- disabledCache := newDisabledCache()
- caches := []Cache{
- newEnabledCache(),
- disabledCache,
- newEnabledCache(),
- newEnabledCache(),
- }
- var removeCalled uint64
- mplex := &cacheMultiplexer{
- caches: caches,
- onCacheRemoved: func(cache Cache, err error) {
- atomic.AddUint64(&removeCalled, 1)
- },
- }
-
- cacheStatus, _, _, err := mplex.Fetch("unused-target", "some-hash", []string{"unused", "files"})
- if err != nil {
- // don't leak the cache removal
- t.Errorf("Fetch got error %v, want <nil>", err)
- }
- hit := cacheStatus.Local || cacheStatus.Remote
- if hit {
- t.Error("hit on empty cache, expected miss")
- }
-
- removes := atomic.LoadUint64(&removeCalled)
- if removes != 1 {
- t.Errorf("removes count: %v, want 1", removes)
- }
-
- mplex.mu.RLock()
- if len(mplex.caches) != 3 {
- t.Errorf("found %v caches, expected to have 3 after one was removed", len(mplex.caches))
- }
- for _, cache := range mplex.caches {
- if cache == disabledCache {
- t.Error("found disabled cache, expected it to be removed")
- }
- }
- mplex.mu.RUnlock()
-}
-
-type nullRecorder struct{}
-
-func (nullRecorder) LogEvent(analytics.EventPayload) {}
-
-func TestNew(t *testing.T) {
- // Test will bomb if this fails, no need to specially handle the error
- repoRoot := fs.AbsoluteSystemPathFromUpstream(t.TempDir())
- type args struct {
- opts Opts
- recorder analytics.Recorder
- onCacheRemoved OnCacheRemoved
- client fakeClient
- }
- tests := []struct {
- name string
- args args
- want Cache
- wantErr bool
- }{
- {
- name: "With no caches configured, new returns a noopCache and an error",
- args: args{
- opts: Opts{
- SkipFilesystem: true,
- SkipRemote: true,
- },
- recorder: &nullRecorder{},
- onCacheRemoved: func(Cache, error) {},
- },
- want: &noopCache{},
- wantErr: true,
- },
- {
- name: "With just httpCache configured, new returns an httpCache and a noopCache",
- args: args{
- opts: Opts{
- SkipFilesystem: true,
- RemoteCacheOpts: fs.RemoteCacheOptions{
- Signature: true,
- },
- },
- recorder: &nullRecorder{},
- onCacheRemoved: func(Cache, error) {},
- },
- want: &cacheMultiplexer{
- caches: []Cache{&httpCache{}, &noopCache{}},
- },
- wantErr: false,
- },
- {
- name: "With just fsCache configured, new returns only an fsCache",
- args: args{
- opts: Opts{
- SkipRemote: true,
- },
- recorder: &nullRecorder{},
- onCacheRemoved: func(Cache, error) {},
- },
- want: &fsCache{},
- },
- {
- name: "With both configured, new returns an fsCache and httpCache",
- args: args{
- opts: Opts{
- RemoteCacheOpts: fs.RemoteCacheOptions{
- Signature: true,
- },
- },
- recorder: &nullRecorder{},
- onCacheRemoved: func(Cache, error) {},
- },
- want: &cacheMultiplexer{
- caches: []Cache{&fsCache{}, &httpCache{}},
- },
- },
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- got, err := New(tt.args.opts, repoRoot, &tt.args.client, tt.args.recorder, tt.args.onCacheRemoved)
- if (err != nil) != tt.wantErr {
- t.Errorf("New() error = %v, wantErr %v", err, tt.wantErr)
- return
- }
- switch multiplexer := got.(type) {
- case *cacheMultiplexer:
- want := tt.want.(*cacheMultiplexer)
- for i := range multiplexer.caches {
- if reflect.TypeOf(multiplexer.caches[i]) != reflect.TypeOf(want.caches[i]) {
- t.Errorf("New() = %v, want %v", reflect.TypeOf(multiplexer.caches[i]), reflect.TypeOf(want.caches[i]))
- }
- }
- case *fsCache:
- if reflect.TypeOf(got) != reflect.TypeOf(tt.want) {
- t.Errorf("New() = %v, want %v", reflect.TypeOf(got), reflect.TypeOf(tt.want))
- }
- case *noopCache:
- if reflect.TypeOf(got) != reflect.TypeOf(tt.want) {
- t.Errorf("New() = %v, want %v", reflect.TypeOf(got), reflect.TypeOf(tt.want))
- }
- }
- })
- }
-}
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2026-01-21 07:44:11 +0000