diff --git a/internal/state/file_manager.go b/internal/state/file_manager.go index c6aaaf0b8e..672855fd4c 100644 --- a/internal/state/file_manager.go +++ b/internal/state/file_manager.go @@ -2,7 +2,6 @@ package state import ( "io/fs" - "io/ioutil" "os" ) @@ -12,8 +11,8 @@ func newStdLibFileManager() *stdLibFileManager { return &stdLibFileManager{} } -func (s *stdLibFileManager) ReadDir(dirname string) ([]fs.FileInfo, error) { - return ioutil.ReadDir(dirname) +func (s *stdLibFileManager) ReadDir(dirname string) ([]fs.DirEntry, error) { + return os.ReadDir(dirname) } func (s *stdLibFileManager) Remove(name string) error { diff --git a/internal/state/secrets.go b/internal/state/secrets.go index 6563e64895..e1f8009a2c 100644 --- a/internal/state/secrets.go +++ b/internal/state/secrets.go @@ -15,7 +15,7 @@ import ( //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 . SecretStore //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 . SecretDiskMemoryManager //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 . FileManager -//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 io/fs.FileInfo +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 io/fs.DirEntry // tlsSecretFileMode defines the default file mode for files with TLS Secrets. const tlsSecretFileMode = 0o600 @@ -78,8 +78,8 @@ type SecretDiskMemoryManager interface { // FileManager is an interface that exposes File I/O operations. // Used for unit testing. type FileManager interface { - // ReadDir returns the file info for the directory. - ReadDir(dirname string) ([]fs.FileInfo, error) + // ReadDir returns the directory entries for the directory. + ReadDir(dirname string) ([]fs.DirEntry, error) // Remove file with given name. Remove(name string) error // Create file at the provided filepath. diff --git a/internal/state/secrets_test.go b/internal/state/secrets_test.go index 997be60ecf..9d4f005a6d 100644 --- a/internal/state/secrets_test.go +++ b/internal/state/secrets_test.go @@ -4,7 +4,6 @@ package state_test import ( "errors" "io/fs" - "io/ioutil" "os" "path" @@ -201,7 +200,7 @@ var _ = Describe("SecretDiskMemoryManager", func() { expectedFileNames := []string{"test_secret1", "test_secret2"} // read all files from directory - dir, err := ioutil.ReadDir(tmpSecretsDir) + dir, err := os.ReadDir(tmpSecretsDir) Expect(err).ToNot(HaveOccurred()) // test that the files exist that we expect @@ -222,7 +221,7 @@ var _ = Describe("SecretDiskMemoryManager", func() { Expect(err).ToNot(HaveOccurred()) // read all files from directory - dir, err := ioutil.ReadDir(tmpSecretsDir) + dir, err := os.ReadDir(tmpSecretsDir) Expect(err).ToNot(HaveOccurred()) // only the secrets stored after the last write should be written to disk. @@ -235,7 +234,7 @@ var _ = Describe("SecretDiskMemoryManager", func() { Expect(err).ToNot(HaveOccurred()) // read all files from directory - dir, err := ioutil.ReadDir(tmpSecretsDir) + dir, err := os.ReadDir(tmpSecretsDir) Expect(err).ToNot(HaveOccurred()) // no secrets should exist @@ -245,16 +244,16 @@ var _ = Describe("SecretDiskMemoryManager", func() { }) Describe("Write all requested secrets", func() { var ( - fakeFileManager *statefakes.FakeFileManager - fakeStore *statefakes.FakeSecretStore - fakeFileInfoSlice []fs.FileInfo - memMgr *state.SecretDiskMemoryManagerImpl + fakeFileManager *statefakes.FakeFileManager + fakeStore *statefakes.FakeSecretStore + fakeDirEntries []fs.DirEntry + memMgr *state.SecretDiskMemoryManagerImpl ) BeforeEach(OncePerOrdered, func() { fakeFileManager = &statefakes.FakeFileManager{} fakeStore = &statefakes.FakeSecretStore{} - fakeFileInfoSlice = []fs.FileInfo{&statefakes.FakeFileInfo{}} + fakeDirEntries = []fs.DirEntry{&statefakes.FakeDirEntry{}} memMgr = state.NewSecretDiskMemoryManager("", fakeStore, state.WithSecretFileManager(fakeFileManager)) // populate a requested secret @@ -276,7 +275,7 @@ var _ = Describe("SecretDiskMemoryManager", func() { }), Entry("remove file error", errors.New("remove file"), func(e error) { - fakeFileManager.ReadDirReturns(fakeFileInfoSlice, nil) + fakeFileManager.ReadDirReturns(fakeDirEntries, nil) fakeFileManager.RemoveReturns(e) }), Entry("create file error", errors.New("create error"), diff --git a/internal/state/statefakes/fake_dir_entry.go b/internal/state/statefakes/fake_dir_entry.go new file mode 100644 index 0000000000..3ec2321a1e --- /dev/null +++ b/internal/state/statefakes/fake_dir_entry.go @@ -0,0 +1,301 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package statefakes + +import ( + "io/fs" + "sync" +) + +type FakeDirEntry struct { + InfoStub func() (fs.FileInfo, error) + infoMutex sync.RWMutex + infoArgsForCall []struct { + } + infoReturns struct { + result1 fs.FileInfo + result2 error + } + infoReturnsOnCall map[int]struct { + result1 fs.FileInfo + result2 error + } + IsDirStub func() bool + isDirMutex sync.RWMutex + isDirArgsForCall []struct { + } + isDirReturns struct { + result1 bool + } + isDirReturnsOnCall map[int]struct { + result1 bool + } + NameStub func() string + nameMutex sync.RWMutex + nameArgsForCall []struct { + } + nameReturns struct { + result1 string + } + nameReturnsOnCall map[int]struct { + result1 string + } + TypeStub func() fs.FileMode + typeMutex sync.RWMutex + typeArgsForCall []struct { + } + typeReturns struct { + result1 fs.FileMode + } + typeReturnsOnCall map[int]struct { + result1 fs.FileMode + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDirEntry) Info() (fs.FileInfo, error) { + fake.infoMutex.Lock() + ret, specificReturn := fake.infoReturnsOnCall[len(fake.infoArgsForCall)] + fake.infoArgsForCall = append(fake.infoArgsForCall, struct { + }{}) + stub := fake.InfoStub + fakeReturns := fake.infoReturns + fake.recordInvocation("Info", []interface{}{}) + fake.infoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeDirEntry) InfoCallCount() int { + fake.infoMutex.RLock() + defer fake.infoMutex.RUnlock() + return len(fake.infoArgsForCall) +} + +func (fake *FakeDirEntry) InfoCalls(stub func() (fs.FileInfo, error)) { + fake.infoMutex.Lock() + defer fake.infoMutex.Unlock() + fake.InfoStub = stub +} + +func (fake *FakeDirEntry) InfoReturns(result1 fs.FileInfo, result2 error) { + fake.infoMutex.Lock() + defer fake.infoMutex.Unlock() + fake.InfoStub = nil + fake.infoReturns = struct { + result1 fs.FileInfo + result2 error + }{result1, result2} +} + +func (fake *FakeDirEntry) InfoReturnsOnCall(i int, result1 fs.FileInfo, result2 error) { + fake.infoMutex.Lock() + defer fake.infoMutex.Unlock() + fake.InfoStub = nil + if fake.infoReturnsOnCall == nil { + fake.infoReturnsOnCall = make(map[int]struct { + result1 fs.FileInfo + result2 error + }) + } + fake.infoReturnsOnCall[i] = struct { + result1 fs.FileInfo + result2 error + }{result1, result2} +} + +func (fake *FakeDirEntry) IsDir() bool { + fake.isDirMutex.Lock() + ret, specificReturn := fake.isDirReturnsOnCall[len(fake.isDirArgsForCall)] + fake.isDirArgsForCall = append(fake.isDirArgsForCall, struct { + }{}) + stub := fake.IsDirStub + fakeReturns := fake.isDirReturns + fake.recordInvocation("IsDir", []interface{}{}) + fake.isDirMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDirEntry) IsDirCallCount() int { + fake.isDirMutex.RLock() + defer fake.isDirMutex.RUnlock() + return len(fake.isDirArgsForCall) +} + +func (fake *FakeDirEntry) IsDirCalls(stub func() bool) { + fake.isDirMutex.Lock() + defer fake.isDirMutex.Unlock() + fake.IsDirStub = stub +} + +func (fake *FakeDirEntry) IsDirReturns(result1 bool) { + fake.isDirMutex.Lock() + defer fake.isDirMutex.Unlock() + fake.IsDirStub = nil + fake.isDirReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeDirEntry) IsDirReturnsOnCall(i int, result1 bool) { + fake.isDirMutex.Lock() + defer fake.isDirMutex.Unlock() + fake.IsDirStub = nil + if fake.isDirReturnsOnCall == nil { + fake.isDirReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isDirReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeDirEntry) Name() string { + fake.nameMutex.Lock() + ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)] + fake.nameArgsForCall = append(fake.nameArgsForCall, struct { + }{}) + stub := fake.NameStub + fakeReturns := fake.nameReturns + fake.recordInvocation("Name", []interface{}{}) + fake.nameMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDirEntry) NameCallCount() int { + fake.nameMutex.RLock() + defer fake.nameMutex.RUnlock() + return len(fake.nameArgsForCall) +} + +func (fake *FakeDirEntry) NameCalls(stub func() string) { + fake.nameMutex.Lock() + defer fake.nameMutex.Unlock() + fake.NameStub = stub +} + +func (fake *FakeDirEntry) NameReturns(result1 string) { + fake.nameMutex.Lock() + defer fake.nameMutex.Unlock() + fake.NameStub = nil + fake.nameReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeDirEntry) NameReturnsOnCall(i int, result1 string) { + fake.nameMutex.Lock() + defer fake.nameMutex.Unlock() + fake.NameStub = nil + if fake.nameReturnsOnCall == nil { + fake.nameReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.nameReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeDirEntry) Type() fs.FileMode { + fake.typeMutex.Lock() + ret, specificReturn := fake.typeReturnsOnCall[len(fake.typeArgsForCall)] + fake.typeArgsForCall = append(fake.typeArgsForCall, struct { + }{}) + stub := fake.TypeStub + fakeReturns := fake.typeReturns + fake.recordInvocation("Type", []interface{}{}) + fake.typeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDirEntry) TypeCallCount() int { + fake.typeMutex.RLock() + defer fake.typeMutex.RUnlock() + return len(fake.typeArgsForCall) +} + +func (fake *FakeDirEntry) TypeCalls(stub func() fs.FileMode) { + fake.typeMutex.Lock() + defer fake.typeMutex.Unlock() + fake.TypeStub = stub +} + +func (fake *FakeDirEntry) TypeReturns(result1 fs.FileMode) { + fake.typeMutex.Lock() + defer fake.typeMutex.Unlock() + fake.TypeStub = nil + fake.typeReturns = struct { + result1 fs.FileMode + }{result1} +} + +func (fake *FakeDirEntry) TypeReturnsOnCall(i int, result1 fs.FileMode) { + fake.typeMutex.Lock() + defer fake.typeMutex.Unlock() + fake.TypeStub = nil + if fake.typeReturnsOnCall == nil { + fake.typeReturnsOnCall = make(map[int]struct { + result1 fs.FileMode + }) + } + fake.typeReturnsOnCall[i] = struct { + result1 fs.FileMode + }{result1} +} + +func (fake *FakeDirEntry) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.infoMutex.RLock() + defer fake.infoMutex.RUnlock() + fake.isDirMutex.RLock() + defer fake.isDirMutex.RUnlock() + fake.nameMutex.RLock() + defer fake.nameMutex.RUnlock() + fake.typeMutex.RLock() + defer fake.typeMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDirEntry) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ fs.DirEntry = new(FakeDirEntry) diff --git a/internal/state/statefakes/fake_file_info.go b/internal/state/statefakes/fake_file_info.go deleted file mode 100644 index e7be531dc8..0000000000 --- a/internal/state/statefakes/fake_file_info.go +++ /dev/null @@ -1,427 +0,0 @@ -// Code generated by counterfeiter. DO NOT EDIT. -package statefakes - -import ( - "io/fs" - "sync" - "time" -) - -type FakeFileInfo struct { - IsDirStub func() bool - isDirMutex sync.RWMutex - isDirArgsForCall []struct { - } - isDirReturns struct { - result1 bool - } - isDirReturnsOnCall map[int]struct { - result1 bool - } - ModTimeStub func() time.Time - modTimeMutex sync.RWMutex - modTimeArgsForCall []struct { - } - modTimeReturns struct { - result1 time.Time - } - modTimeReturnsOnCall map[int]struct { - result1 time.Time - } - ModeStub func() fs.FileMode - modeMutex sync.RWMutex - modeArgsForCall []struct { - } - modeReturns struct { - result1 fs.FileMode - } - modeReturnsOnCall map[int]struct { - result1 fs.FileMode - } - NameStub func() string - nameMutex sync.RWMutex - nameArgsForCall []struct { - } - nameReturns struct { - result1 string - } - nameReturnsOnCall map[int]struct { - result1 string - } - SizeStub func() int64 - sizeMutex sync.RWMutex - sizeArgsForCall []struct { - } - sizeReturns struct { - result1 int64 - } - sizeReturnsOnCall map[int]struct { - result1 int64 - } - SysStub func() any - sysMutex sync.RWMutex - sysArgsForCall []struct { - } - sysReturns struct { - result1 any - } - sysReturnsOnCall map[int]struct { - result1 any - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeFileInfo) IsDir() bool { - fake.isDirMutex.Lock() - ret, specificReturn := fake.isDirReturnsOnCall[len(fake.isDirArgsForCall)] - fake.isDirArgsForCall = append(fake.isDirArgsForCall, struct { - }{}) - stub := fake.IsDirStub - fakeReturns := fake.isDirReturns - fake.recordInvocation("IsDir", []interface{}{}) - fake.isDirMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeFileInfo) IsDirCallCount() int { - fake.isDirMutex.RLock() - defer fake.isDirMutex.RUnlock() - return len(fake.isDirArgsForCall) -} - -func (fake *FakeFileInfo) IsDirCalls(stub func() bool) { - fake.isDirMutex.Lock() - defer fake.isDirMutex.Unlock() - fake.IsDirStub = stub -} - -func (fake *FakeFileInfo) IsDirReturns(result1 bool) { - fake.isDirMutex.Lock() - defer fake.isDirMutex.Unlock() - fake.IsDirStub = nil - fake.isDirReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeFileInfo) IsDirReturnsOnCall(i int, result1 bool) { - fake.isDirMutex.Lock() - defer fake.isDirMutex.Unlock() - fake.IsDirStub = nil - if fake.isDirReturnsOnCall == nil { - fake.isDirReturnsOnCall = make(map[int]struct { - result1 bool - }) - } - fake.isDirReturnsOnCall[i] = struct { - result1 bool - }{result1} -} - -func (fake *FakeFileInfo) ModTime() time.Time { - fake.modTimeMutex.Lock() - ret, specificReturn := fake.modTimeReturnsOnCall[len(fake.modTimeArgsForCall)] - fake.modTimeArgsForCall = append(fake.modTimeArgsForCall, struct { - }{}) - stub := fake.ModTimeStub - fakeReturns := fake.modTimeReturns - fake.recordInvocation("ModTime", []interface{}{}) - fake.modTimeMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeFileInfo) ModTimeCallCount() int { - fake.modTimeMutex.RLock() - defer fake.modTimeMutex.RUnlock() - return len(fake.modTimeArgsForCall) -} - -func (fake *FakeFileInfo) ModTimeCalls(stub func() time.Time) { - fake.modTimeMutex.Lock() - defer fake.modTimeMutex.Unlock() - fake.ModTimeStub = stub -} - -func (fake *FakeFileInfo) ModTimeReturns(result1 time.Time) { - fake.modTimeMutex.Lock() - defer fake.modTimeMutex.Unlock() - fake.ModTimeStub = nil - fake.modTimeReturns = struct { - result1 time.Time - }{result1} -} - -func (fake *FakeFileInfo) ModTimeReturnsOnCall(i int, result1 time.Time) { - fake.modTimeMutex.Lock() - defer fake.modTimeMutex.Unlock() - fake.ModTimeStub = nil - if fake.modTimeReturnsOnCall == nil { - fake.modTimeReturnsOnCall = make(map[int]struct { - result1 time.Time - }) - } - fake.modTimeReturnsOnCall[i] = struct { - result1 time.Time - }{result1} -} - -func (fake *FakeFileInfo) Mode() fs.FileMode { - fake.modeMutex.Lock() - ret, specificReturn := fake.modeReturnsOnCall[len(fake.modeArgsForCall)] - fake.modeArgsForCall = append(fake.modeArgsForCall, struct { - }{}) - stub := fake.ModeStub - fakeReturns := fake.modeReturns - fake.recordInvocation("Mode", []interface{}{}) - fake.modeMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeFileInfo) ModeCallCount() int { - fake.modeMutex.RLock() - defer fake.modeMutex.RUnlock() - return len(fake.modeArgsForCall) -} - -func (fake *FakeFileInfo) ModeCalls(stub func() fs.FileMode) { - fake.modeMutex.Lock() - defer fake.modeMutex.Unlock() - fake.ModeStub = stub -} - -func (fake *FakeFileInfo) ModeReturns(result1 fs.FileMode) { - fake.modeMutex.Lock() - defer fake.modeMutex.Unlock() - fake.ModeStub = nil - fake.modeReturns = struct { - result1 fs.FileMode - }{result1} -} - -func (fake *FakeFileInfo) ModeReturnsOnCall(i int, result1 fs.FileMode) { - fake.modeMutex.Lock() - defer fake.modeMutex.Unlock() - fake.ModeStub = nil - if fake.modeReturnsOnCall == nil { - fake.modeReturnsOnCall = make(map[int]struct { - result1 fs.FileMode - }) - } - fake.modeReturnsOnCall[i] = struct { - result1 fs.FileMode - }{result1} -} - -func (fake *FakeFileInfo) Name() string { - fake.nameMutex.Lock() - ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)] - fake.nameArgsForCall = append(fake.nameArgsForCall, struct { - }{}) - stub := fake.NameStub - fakeReturns := fake.nameReturns - fake.recordInvocation("Name", []interface{}{}) - fake.nameMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeFileInfo) NameCallCount() int { - fake.nameMutex.RLock() - defer fake.nameMutex.RUnlock() - return len(fake.nameArgsForCall) -} - -func (fake *FakeFileInfo) NameCalls(stub func() string) { - fake.nameMutex.Lock() - defer fake.nameMutex.Unlock() - fake.NameStub = stub -} - -func (fake *FakeFileInfo) NameReturns(result1 string) { - fake.nameMutex.Lock() - defer fake.nameMutex.Unlock() - fake.NameStub = nil - fake.nameReturns = struct { - result1 string - }{result1} -} - -func (fake *FakeFileInfo) NameReturnsOnCall(i int, result1 string) { - fake.nameMutex.Lock() - defer fake.nameMutex.Unlock() - fake.NameStub = nil - if fake.nameReturnsOnCall == nil { - fake.nameReturnsOnCall = make(map[int]struct { - result1 string - }) - } - fake.nameReturnsOnCall[i] = struct { - result1 string - }{result1} -} - -func (fake *FakeFileInfo) Size() int64 { - fake.sizeMutex.Lock() - ret, specificReturn := fake.sizeReturnsOnCall[len(fake.sizeArgsForCall)] - fake.sizeArgsForCall = append(fake.sizeArgsForCall, struct { - }{}) - stub := fake.SizeStub - fakeReturns := fake.sizeReturns - fake.recordInvocation("Size", []interface{}{}) - fake.sizeMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeFileInfo) SizeCallCount() int { - fake.sizeMutex.RLock() - defer fake.sizeMutex.RUnlock() - return len(fake.sizeArgsForCall) -} - -func (fake *FakeFileInfo) SizeCalls(stub func() int64) { - fake.sizeMutex.Lock() - defer fake.sizeMutex.Unlock() - fake.SizeStub = stub -} - -func (fake *FakeFileInfo) SizeReturns(result1 int64) { - fake.sizeMutex.Lock() - defer fake.sizeMutex.Unlock() - fake.SizeStub = nil - fake.sizeReturns = struct { - result1 int64 - }{result1} -} - -func (fake *FakeFileInfo) SizeReturnsOnCall(i int, result1 int64) { - fake.sizeMutex.Lock() - defer fake.sizeMutex.Unlock() - fake.SizeStub = nil - if fake.sizeReturnsOnCall == nil { - fake.sizeReturnsOnCall = make(map[int]struct { - result1 int64 - }) - } - fake.sizeReturnsOnCall[i] = struct { - result1 int64 - }{result1} -} - -func (fake *FakeFileInfo) Sys() any { - fake.sysMutex.Lock() - ret, specificReturn := fake.sysReturnsOnCall[len(fake.sysArgsForCall)] - fake.sysArgsForCall = append(fake.sysArgsForCall, struct { - }{}) - stub := fake.SysStub - fakeReturns := fake.sysReturns - fake.recordInvocation("Sys", []interface{}{}) - fake.sysMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeFileInfo) SysCallCount() int { - fake.sysMutex.RLock() - defer fake.sysMutex.RUnlock() - return len(fake.sysArgsForCall) -} - -func (fake *FakeFileInfo) SysCalls(stub func() any) { - fake.sysMutex.Lock() - defer fake.sysMutex.Unlock() - fake.SysStub = stub -} - -func (fake *FakeFileInfo) SysReturns(result1 any) { - fake.sysMutex.Lock() - defer fake.sysMutex.Unlock() - fake.SysStub = nil - fake.sysReturns = struct { - result1 any - }{result1} -} - -func (fake *FakeFileInfo) SysReturnsOnCall(i int, result1 any) { - fake.sysMutex.Lock() - defer fake.sysMutex.Unlock() - fake.SysStub = nil - if fake.sysReturnsOnCall == nil { - fake.sysReturnsOnCall = make(map[int]struct { - result1 any - }) - } - fake.sysReturnsOnCall[i] = struct { - result1 any - }{result1} -} - -func (fake *FakeFileInfo) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.isDirMutex.RLock() - defer fake.isDirMutex.RUnlock() - fake.modTimeMutex.RLock() - defer fake.modTimeMutex.RUnlock() - fake.modeMutex.RLock() - defer fake.modeMutex.RUnlock() - fake.nameMutex.RLock() - defer fake.nameMutex.RUnlock() - fake.sizeMutex.RLock() - defer fake.sizeMutex.RUnlock() - fake.sysMutex.RLock() - defer fake.sysMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeFileInfo) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ fs.FileInfo = new(FakeFileInfo) diff --git a/internal/state/statefakes/fake_file_manager.go b/internal/state/statefakes/fake_file_manager.go index f36e690ae4..dbde4d6b9b 100644 --- a/internal/state/statefakes/fake_file_manager.go +++ b/internal/state/statefakes/fake_file_manager.go @@ -35,17 +35,17 @@ type FakeFileManager struct { result1 *os.File result2 error } - ReadDirStub func(string) ([]fs.FileInfo, error) + ReadDirStub func(string) ([]fs.DirEntry, error) readDirMutex sync.RWMutex readDirArgsForCall []struct { arg1 string } readDirReturns struct { - result1 []fs.FileInfo + result1 []fs.DirEntry result2 error } readDirReturnsOnCall map[int]struct { - result1 []fs.FileInfo + result1 []fs.DirEntry result2 error } RemoveStub func(string) error @@ -201,7 +201,7 @@ func (fake *FakeFileManager) CreateReturnsOnCall(i int, result1 *os.File, result }{result1, result2} } -func (fake *FakeFileManager) ReadDir(arg1 string) ([]fs.FileInfo, error) { +func (fake *FakeFileManager) ReadDir(arg1 string) ([]fs.DirEntry, error) { fake.readDirMutex.Lock() ret, specificReturn := fake.readDirReturnsOnCall[len(fake.readDirArgsForCall)] fake.readDirArgsForCall = append(fake.readDirArgsForCall, struct { @@ -226,7 +226,7 @@ func (fake *FakeFileManager) ReadDirCallCount() int { return len(fake.readDirArgsForCall) } -func (fake *FakeFileManager) ReadDirCalls(stub func(string) ([]fs.FileInfo, error)) { +func (fake *FakeFileManager) ReadDirCalls(stub func(string) ([]fs.DirEntry, error)) { fake.readDirMutex.Lock() defer fake.readDirMutex.Unlock() fake.ReadDirStub = stub @@ -239,28 +239,28 @@ func (fake *FakeFileManager) ReadDirArgsForCall(i int) string { return argsForCall.arg1 } -func (fake *FakeFileManager) ReadDirReturns(result1 []fs.FileInfo, result2 error) { +func (fake *FakeFileManager) ReadDirReturns(result1 []fs.DirEntry, result2 error) { fake.readDirMutex.Lock() defer fake.readDirMutex.Unlock() fake.ReadDirStub = nil fake.readDirReturns = struct { - result1 []fs.FileInfo + result1 []fs.DirEntry result2 error }{result1, result2} } -func (fake *FakeFileManager) ReadDirReturnsOnCall(i int, result1 []fs.FileInfo, result2 error) { +func (fake *FakeFileManager) ReadDirReturnsOnCall(i int, result1 []fs.DirEntry, result2 error) { fake.readDirMutex.Lock() defer fake.readDirMutex.Unlock() fake.ReadDirStub = nil if fake.readDirReturnsOnCall == nil { fake.readDirReturnsOnCall = make(map[int]struct { - result1 []fs.FileInfo + result1 []fs.DirEntry result2 error }) } fake.readDirReturnsOnCall[i] = struct { - result1 []fs.FileInfo + result1 []fs.DirEntry result2 error }{result1, result2} }