Add Open() test for s3 backend

Author: ThisaraWeerakoon

backend/gs/location_test.go

@@ -365,12 +365,12 @@ func (lt *locationTestSuite) TestOpen() {
 	// Test opening a non-existent file
 	_, err = loc.Open("non-existent-file.txt")
 	lt.Error(err, "Opening a non-existent file should return an error")
-	lt.Contains(err.Error(), "ErrNotExist", "Error should indicate file does not exist")
+	lt.Contains(err.Error(), "file does not exist", "Error should indicate file does not exist")
 
 	// Test opening with path traversal
 	_, err = loc.Open("../outside.txt")
 	lt.Error(err, "Opening a file with path traversal should return an error")
-	lt.Contains(err.Error(), "ErrInvalid", "Error should indicate invalid path")
+	lt.Contains(err.Error(), "invalid argument", "Error should indicate invalid path")
 
 	// Test opening with dot paths
 	_, err = loc.Open(".")

backend/mem/file_test.go

@@ -770,14 +770,14 @@ func (s *memFileTest) TestStat() {
 	fileInfo, err := s.testFile.Stat()
 	s.NoError(err, "stat error not expected")
 	s.NotNil(fileInfo, "FileInfo should not be nil")
-	
+
 	// Check file info properties
 	s.Equal("test.txt", fileInfo.Name(), "FileInfo name should match file name")
 	s.Equal(int64(len(expectedContent)), fileInfo.Size(), "FileInfo size should match content length")
 	s.False(fileInfo.IsDir(), "FileInfo should indicate file is not a directory")
 	s.NotNil(fileInfo.ModTime(), "ModTime should not be nil")
 	s.Equal(0644, int(fileInfo.Mode()), "Mode should be 0644")
-	
+
 	// Test Stat on non-existent file
 	nonExistentFile, err := s.fileSystem.NewFile("", "/non-existent-file.txt")
 	s.NoError(err, "error creating reference to non-existent file")

backend/mem/location_test.go

@@ -350,48 +350,48 @@ func (s *memLocationTest) TestOpen() {
 	testContent := "hello world"
 	testFileName := "open_test_file.txt"
 	testFilePath := "/test_files/" + testFileName
-	
+
 	// Create a file and write content
 	file, err := s.fileSystem.NewFile("", testFilePath)
 	s.NoError(err, "error not expected when creating a new file")
 	_, err = file.Write([]byte(testContent))
 	s.NoError(err, "write error not expected")
 	s.NoError(file.Close(), "close error not expected")
-	
+
 	// Get the file's location
 	loc := file.Location()
-	
+
 	// Test Opening the file
 	opened, err := loc.Open(testFileName)
 	s.NoError(err, "error not expected when opening existing file")
 	s.NotNil(opened, "opened file should not be nil")
-	
+
 	// Read the content to verify
 	data := make([]byte, len(testContent))
 	n, err := opened.Read(data)
 	s.NoError(err, "read error not expected")
 	s.Equal(len(testContent), n, "should read all content")
 	s.Equal(testContent, string(data), "content should match")
-	
+
 	// Test opening non-existent file
 	_, err = loc.Open("non-existent-file.txt")
 	s.Error(err, "error expected when opening non-existent file")
 	var pathErr *fs.PathError
 	s.True(errors.As(err, &pathErr), "error should be a fs.PathError")
 	s.ErrorIs(pathErr.Err, fs.ErrNotExist, "underlying error should be fs.ErrNotExist")
-	
+
 	// Test opening with path traversal attempts (should be rejected)
 	_, err = loc.Open("../outside.txt")
 	s.Error(err, "error expected when path contains traversal")
 	s.True(errors.As(err, &pathErr), "error should be a fs.PathError")
 	s.ErrorIs(pathErr.Err, fs.ErrInvalid, "underlying error should be fs.ErrInvalid")
-	
+
 	_, err = loc.Open("./file.txt")
 	s.Error(err, "error expected when path contains ./")
-	
+
 	_, err = loc.Open(".")
 	s.Error(err, "error expected when path is .")
-	
+
 	_, err = loc.Open("..")
 	s.Error(err, "error expected when path is ..")
 }

backend/os/file_test.go

@@ -755,7 +755,7 @@ func (s *osFileTest) TestStat() {
 	s.NoError(err, "error creating reference to non-existent file")
 	_, err = nonExistentFile.Stat()
 	s.Error(err, "error expected when calling Stat on non-existent file")
-	s.True(os.IsNotExist(err), "error should be os.IsNotExist")
+	s.Contains(err.Error(), "no such file or directory", "error should indicate no such file")
 }
 
 func TestOSFile(t *testing.T) {

backend/s3/location_test.go

@@ -4,6 +4,7 @@ import (
 	"path"
 	"regexp"
 	"testing"
+	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
@@ -342,6 +343,61 @@ func (lt *locationTestSuite) TestDeleteFileWithAllVersionsOption() {
 	lt.s3cliMock.AssertNumberOfCalls(lt.T(), "DeleteObject", 3)
 }
 
+// TestOpen tests the Open method for the S3 location
+func (lt *locationTestSuite) TestOpen() {
+	// Setup test values
+	bucket := "test-bucket"
+	locPath := "/test-dir/"
+	filename := "test-file.txt"
+
+	// Create location
+	loc, err := lt.fs.NewLocation(bucket, locPath)
+	lt.NoError(err, "Creating location shouldn't return an error")
+
+	// Mock the HeadObject response for checking existence
+	lt.s3cliMock.On("HeadObject", matchContext, mock.Anything).Return(&s3.HeadObjectOutput{
+		ContentLength: aws.Int64(42),
+		LastModified:  aws.Time(time.Now()),
+	}, nil).Once()
+
+	// Test opening an existing file
+	file, err := loc.Open(filename)
+	lt.NoError(err, "Opening an existing file should not return an error")
+	lt.NotNil(file, "Returned file should not be nil")
+
+	// Verify mock expectations
+	lt.s3cliMock.AssertExpectations(lt.T())
+
+	// Test opening a non-existent file
+	// Setup mock to indicate file doesn't exist
+	lt.s3cliMock.On("HeadObject", matchContext, mock.Anything).Return(nil, &types.NotFound{
+		Message: aws.String("Not Found"),
+	}).Once()
+
+	// Attempt to open a non-existent file
+	_, err = loc.Open("non-existent.txt")
+	lt.Error(err, "Opening a non-existent file should return an error")
+	lt.Contains(err.Error(), "file does not exist", "Error should indicate file does not exist")
+
+	// Test opening with path traversal
+	_, err = loc.Open("../outside.txt")
+	lt.Error(err, "Opening a file with path traversal should return an error")
+	lt.Contains(err.Error(), "invalid argument", "Error should indicate invalid path")
+
+	// Test opening with dot paths
+	_, err = loc.Open(".")
+	lt.Error(err, "Opening '.' should return an error")
+
+	_, err = loc.Open("..")
+	lt.Error(err, "Opening '..' should return an error")
+
+	_, err = loc.Open("./file.txt")
+	lt.Error(err, "Opening path with './' should return an error")
+
+	// Verify all mock expectations
+	lt.s3cliMock.AssertExpectations(lt.T())
+}
+
 func TestLocation(t *testing.T) {
 	suite.Run(t, new(locationTestSuite))
 }