Use typed expectations

Author: NathanBaulch

CHANGELOG.md

@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Tests
+- Use typed expectations consistently for added type safety.
 
 ## [v7.10.0] - 2025-10-07
 ### Security

backend/ftp/location_test.go

@@ -51,7 +51,7 @@ func (lt *locationTestSuite) TestList() {
 	}
 	authorityStr := "host.com"
 	locPath := "/dir1/"
-	lt.client.On("List", locPath).Return(entries, nil).Once()
+	lt.client.EXPECT().List(locPath).Return(entries, nil).Once()
 
 	loc, err := lt.ftpfs.NewLocation(authorityStr, locPath)
 	lt.Require().NoError(err)
@@ -63,13 +63,13 @@ func (lt *locationTestSuite) TestList() {
 	}
 
 	// file not found (location doesn't exist)
-	lt.client.On("List", locPath).Return([]*_ftp.Entry{}, errors.New("some error")).Once()
+	lt.client.EXPECT().List(locPath).Return([]*_ftp.Entry{}, errors.New("some error")).Once()
 	fileList, err = loc.List()
 	lt.Require().Error(err, "should return error")
 	lt.Empty(fileList, "Should return no files on error")
 
 	// file not found (location doesn't exist)
-	lt.client.On("List", locPath).Return([]*_ftp.Entry{}, errors.New("550")).Once()
+	lt.client.EXPECT().List(locPath).Return([]*_ftp.Entry{}, errors.New("550")).Once()
 	fileList, err = loc.List()
 	lt.Require().NoError(err, "Shouldn't return an error on file not found.")
 	lt.Empty(fileList, "Should return no files on file not found")
@@ -287,7 +287,7 @@ func (lt *locationTestSuite) TestListByRegex() {
 	}
 	authorityStr := "host.com"
 	locPath := "/dir1/"
-	lt.client.On("List", locPath).Return(entries, nil).Once()
+	lt.client.EXPECT().List(locPath).Return(entries, nil).Once()
 	loc, err := lt.ftpfs.NewLocation(authorityStr, locPath)
 	lt.Require().NoError(err)
 
@@ -301,7 +301,7 @@ func (lt *locationTestSuite) TestListByRegex() {
 
 	// ListByRegex Returns List error
 	listErr := errors.New("some list error")
-	lt.client.On("List", locPath).Return(nil, listErr).Once()
+	lt.client.EXPECT().List(locPath).Return(nil, listErr).Once()
 	fileList, err = loc.ListByRegex(fileTypeRegex)
 	lt.Require().Error(err, "error is expected")
 	lt.Require().ErrorIs(err, listErr, "error is right kind of error")
@@ -423,7 +423,7 @@ func (lt *locationTestSuite) TestExists() {
 			Time:   time.Now().UTC(),
 		},
 	}
-	lt.client.On("List", locPath).Return(entries, nil).Once()
+	lt.client.EXPECT().List(locPath).Return(entries, nil).Once()
 	loc, err := lt.ftpfs.NewLocation(authorityStr, locPath)
 	lt.Require().NoError(err)
 	exists, err := loc.Exists()
@@ -440,15 +440,15 @@ func (lt *locationTestSuite) TestExists() {
 			Time:   time.Now().UTC(),
 		},
 	}
-	lt.client.On("List", "/my/").Return(entries, nil).Once()
+	lt.client.EXPECT().List("/my/").Return(entries, nil).Once()
 	loc, err = lt.ftpfs.NewLocation(authorityStr, locPath)
 	lt.Require().NoError(err)
 	exists, err = loc.Exists()
 	lt.Require().NoError(err, "No error expected from Exists")
 	lt.False(exists, "Call to Exists expected to return false.")
 
 	// some error calling list
-	lt.client.On("List", "/my/").Return(entries, errors.New("some error")).Once()
+	lt.client.EXPECT().List("/my/").Return(entries, errors.New("some error")).Once()
 	loc, err = lt.ftpfs.NewLocation(authorityStr, locPath)
 	lt.Require().NoError(err)
 	exists, err = loc.Exists()
@@ -470,7 +470,7 @@ func (lt *locationTestSuite) TestExists() {
 			Time:   time.Now().UTC(),
 		},
 	}
-	lt.client.On("List", "/my/").Return(entries, nil).Once()
+	lt.client.EXPECT().List("/my/").Return(entries, nil).Once()
 	loc, err = lt.ftpfs.NewLocation(authorityStr, locPath)
 	lt.Require().NoError(err)
 	exists, err = loc.Exists()
@@ -543,7 +543,7 @@ func (lt *locationTestSuite) TestDeleteFile() {
 	// error deleting
 	dataConnGetterFunc = getDataConn
 	loc.(*Location).fileSystem.dataconn = nil
-	lt.client.On("Delete", "/old/filename.txt").Return(os.ErrNotExist).Once()
+	lt.client.EXPECT().Delete("/old/filename.txt").Return(os.ErrNotExist).Once()
 	err = loc.DeleteFile("filename.txt")
 	lt.Require().Error(err, "failed delete")
 	lt.Require().ErrorIs(err, os.ErrNotExist, "error should be right kind of error")

backend/os/file_test.go

@@ -181,9 +181,9 @@ func (s *osFileTest) TestCopyToLocation() {
 	otherFile := mocks.NewFile(s.T())
 
 	// Expected behavior
-	otherFile.On("Write", mock.Anything).Return(len(expectedText), nil)
-	otherFile.On("Close").Return(nil)
-	otherFs.On("NewFile", mock.Anything, mock.Anything).Return(otherFile, nil)
+	otherFile.EXPECT().Write(mock.Anything).Return(len(expectedText), nil)
+	otherFile.EXPECT().Close().Return(nil)
+	otherFs.EXPECT().NewFile(mock.Anything, mock.Anything).Return(otherFile, nil)
 
 	location := Location{name: "/some/path", fileSystem: otherFs}
 
@@ -203,12 +203,12 @@ func (s *osFileTest) TestCopyToFile() {
 	location := Location{name: "/some/path", fileSystem: otherFs}
 
 	// Expected behavior
-	otherFile.On("Write", []uint8(expectedText)).Return(len(expectedText), nil)
-	otherFile.On("Close").Return(nil)
-	otherFile.On("Name").Return("other.txt")
-	otherFile.On("Location").Return(vfs.Location(&location))
+	otherFile.EXPECT().Write([]uint8(expectedText)).Return(len(expectedText), nil)
+	otherFile.EXPECT().Close().Return(nil)
+	otherFile.EXPECT().Name().Return("other.txt")
+	otherFile.EXPECT().Location().Return(vfs.Location(&location))
 
-	otherFs.On("NewFile", "", "/some/path/other.txt").Return(otherFile, nil)
+	otherFs.EXPECT().NewFile("", "/some/path/other.txt").Return(otherFile, nil)
 
 	err := s.testFile.CopyToFile(otherFile)
 	s.Require().NoError(err)
@@ -222,12 +222,12 @@ func (s *osFileTest) TestEmptyCopyToFile() {
 	location := Location{name: "/some/path", fileSystem: otherFs}
 
 	// Expected behavior
-	otherFile.On("Write", []uint8(expectedText)).Return(len(expectedText), nil)
-	otherFile.On("Close").Return(nil)
-	otherFile.On("Name").Return("other.txt")
-	otherFile.On("Location").Return(vfs.Location(&location))
+	otherFile.EXPECT().Write([]uint8(expectedText)).Return(len(expectedText), nil)
+	otherFile.EXPECT().Close().Return(nil)
+	otherFile.EXPECT().Name().Return("other.txt")
+	otherFile.EXPECT().Location().Return(vfs.Location(&location))
 
-	otherFs.On("NewFile", "", "/some/path/other.txt").Return(otherFile, nil)
+	otherFs.EXPECT().NewFile("", "/some/path/other.txt").Return(otherFile, nil)
 
 	emptyFile, err := s.tmploc.NewFile("test_files/empty.txt")
 	s.Require().NoError(err, "No file was opened")
@@ -242,9 +242,9 @@ func (s *osFileTest) TestCopyToLocationIgnoreExtraSeparator() {
 	otherFile := mocks.NewFile(s.T())
 
 	// Expected behavior
-	otherFile.On("Write", mock.Anything).Return(len(expectedText), nil)
-	otherFile.On("Close").Return(nil)
-	otherFs.On("NewFile", "", "/some/path/test.txt").Return(otherFile, nil)
+	otherFile.EXPECT().Write(mock.Anything).Return(len(expectedText), nil)
+	otherFile.EXPECT().Close().Return(nil)
+	otherFs.EXPECT().NewFile("", "/some/path/test.txt").Return(otherFile, nil)
 
 	// Add trailing slash
 	location := Location{name: "/some/path/", fileSystem: otherFs}
@@ -295,19 +295,19 @@ func (s *osFileTest) TestMoveToLocation() {
 	s.Require().NoError(err)
 
 	// Expected behavior
-	mockfs.On("Scheme").Return("mock")
+	mockfs.EXPECT().Scheme().Return("mock")
 	fsMockFile := mocks.NewFile(s.T())
-	fsMockFile.On("Write", mock.Anything).Return(10, nil)
-	fsMockFile.On("Close").Return(nil)
-	mockfs.On("NewFile", mock.Anything, mock.Anything).Return(fsMockFile, nil)
-	mockLocation.On("FileSystem").Return(mockfs)
-	mockLocation.On("Authority").Return(auth)
-	mockLocation.On("Path").Return("/some/path/to/")
+	fsMockFile.EXPECT().Write(mock.Anything).Return(10, nil)
+	fsMockFile.EXPECT().Close().Return(nil)
+	mockfs.EXPECT().NewFile(mock.Anything, mock.Anything).Return(fsMockFile, nil)
+	mockLocation.EXPECT().FileSystem().Return(mockfs)
+	mockLocation.EXPECT().Authority().Return(auth)
+	mockLocation.EXPECT().Path().Return("/some/path/to/")
 	mockFile := mocks.NewFile(s.T())
-	mockFile.On("Location").Return(mockLocation, nil)
-	mockFile.On("Name").Return("/some/path/to/move.txt")
-	mockFile.On("Location").Return(mockLocation, nil)
-	mockLocation.On("NewFile", mock.Anything).Return(mockFile, nil)
+	mockFile.EXPECT().Location().Return(mockLocation)
+	mockFile.EXPECT().Name().Return("/some/path/to/move.txt")
+	mockFile.EXPECT().Location().Return(mockLocation)
+	mockLocation.EXPECT().NewFile(mock.Anything).Return(mockFile, nil)
 
 	_, err = movedFile.MoveToLocation(mockLocation)
 	s.Require().NoError(err)
@@ -425,17 +425,17 @@ func (s *osFileTest) TestMoveToFile() {
 	s.Require().NoError(err)
 
 	// Expected behavior
-	mockfs.On("Scheme").Return("mock")
+	mockfs.EXPECT().Scheme().Return("mock")
 	fsMockFile := mocks.NewFile(s.T())
-	fsMockFile.On("Write", mock.Anything).Return(13, nil)
-	fsMockFile.On("Close").Return(nil)
-	mockfs.On("NewFile", mock.Anything, mock.Anything).Return(fsMockFile, nil)
-	mockLocation.On("FileSystem").Return(mockfs)
-	mockLocation.On("Authority").Return(auth)
-	mockLocation.On("Path").Return("/some/path/to/")
-	mockFile.On("Location").Return(mockLocation, nil)
-	mockFile.On("Name").Return("/some/path/to/file.txt")
-	mockFile.On("Location").Return(mockLocation, nil)
+	fsMockFile.EXPECT().Write(mock.Anything).Return(13, nil)
+	fsMockFile.EXPECT().Close().Return(nil)
+	mockfs.EXPECT().NewFile(mock.Anything, mock.Anything).Return(fsMockFile, nil)
+	mockLocation.EXPECT().FileSystem().Return(mockfs)
+	mockLocation.EXPECT().Authority().Return(auth)
+	mockLocation.EXPECT().Path().Return("/some/path/to/")
+	mockFile.EXPECT().Location().Return(mockLocation)
+	mockFile.EXPECT().Name().Return("/some/path/to/file.txt")
+	mockFile.EXPECT().Location().Return(mockLocation)
 
 	s.Require().NoError(file2.MoveToFile(mockFile))
 }

backend/s3/doc.go

@@ -52,7 +52,7 @@ would have to be cast as s3.FileSystem to use the following:
 	    // to pass specific client, for instance a mock client
 	    s3MockClient := mocks.NewClient(t)
 	    s3MockClient.EXPECT().
-	        GetObject(matchContext, mock.AnythingOfType("*s3.GetObjectInput")).
+	        GetObject(matchContext, mock.IsType((*s3.GetObjectInput)(nil))).
 	        Return(&s3.GetObjectOutput{
 	            Body: nopCloser{bytes.NewBufferString("Hello world!")},
 	            }, nil)