migration buffered read

Author: PranjalC100

tools/integration_tests/buffered_read/fallback_test.go

@@ -15,6 +15,7 @@
 package buffered_read
 
 import (
+	"log"
 	"os"
 	"path"
 	"syscall"
@@ -36,17 +37,15 @@ import (
 // fallbackSuiteBase provides shared setup and teardown logic for fallback-related test suites.
 type fallbackSuiteBase struct {
 	suite.Suite
-	testFlags *gcsfuseTestFlags
+	flags []string
 }
 
 func (s *fallbackSuiteBase) SetupSuite() {
 	if setup.MountedDirectory() != "" {
 		setupForMountedDirectoryTests()
 		return
 	}
-	configFile := createConfigFile(s.testFlags)
-	flags := []string{"--config-file=" + configFile}
-	setup.MountGCSFuseWithGivenMountFunc(flags, mountFunc)
+	setup.MountGCSFuseWithGivenMountWithConfigFunc(testEnv.cfg, s.flags, mountFunc)
 }
 
 func (s *fallbackSuiteBase) SetupTest() {
@@ -59,7 +58,7 @@ func (s *fallbackSuiteBase) TearDownSuite() {
 		setup.SaveGCSFuseLogFileInCaseOfFailure(s.T())
 		return
 	}
-	setup.UnmountGCSFuse(rootDir)
+	setup.UnmountGCSFuseWithConfig(testEnv.cfg)
 	setup.SaveGCSFuseLogFileInCaseOfFailure(s.T())
 }
 
@@ -83,7 +82,7 @@ type RandomReadFallbackSuite struct {
 // the BufferedReader is not created, and reads fall back to the next reader
 // without any buffered reading.
 func (s *InsufficientPoolCreationSuite) TestNewBufferedReader_InsufficientGlobalPool_NoReaderAdded() {
-	fileSize := 3 * s.testFlags.blockSizeMB * util.MiB
+	fileSize := int64(3 * 8 * util.MiB)
 	chunkSize := int64(1 * util.MiB)
 	testDir := setup.SetupTestDirectory(testDirName)
 	fileName := setupFileInTestDir(ctx, storageClient, testDir, fileSize, s.T())
@@ -104,7 +103,7 @@ func (s *InsufficientPoolCreationSuite) TestNewBufferedReader_InsufficientGlobal
 
 func (s *RandomReadFallbackSuite) TestRandomRead_Fallback() {
 	const randomReadsThreshold = 3
-	blockSizeInBytes := s.testFlags.blockSizeMB * util.MiB
+	blockSizeInBytes := int64(8 * util.MiB)
 	// Create a file with 4 blocks. We will read backwards from block 3 to 0
 	// to trigger random seek detection.
 	numBlocks := 4
@@ -126,7 +125,7 @@ func (s *RandomReadFallbackSuite) TestRandomRead_Fallback() {
 }
 
 func (s *RandomReadFallbackSuite) TestRandomRead_SmallFile_NoFallback() {
-	blockSizeInBytes := s.testFlags.blockSizeMB * util.MiB
+	blockSizeInBytes := int64(8 * util.MiB)
 	// File size is small, less than one block.
 	fileSize := blockSizeInBytes / 2
 	chunkSize := int64(1 * util.KiB)
@@ -182,46 +181,32 @@ func (s *RandomReadFallbackSuite) TestRandomThenSequential_SwitchesBackToBuffere
 // Test Function (Runs once before all tests)
 ////////////////////////////////////////////////////////////////////////
 
-func TestFallbackSuites(t *testing.T) {
-	// Define base flags for insufficient pool creation tests.
-	baseInsufficientPoolFlags := gcsfuseTestFlags{
-		enableBufferedRead:   true,
-		blockSizeMB:          8,
-		minBlocksPerHandle:   2,
-		globalMaxBlocks:      1, // Less than min-blocks-per-handle
-		maxBlocksPerHandle:   10,
-		startBlocksPerHandle: 2,
-	}
+func TestInsufficientPoolCreationSuite(t *testing.T) {
+	ts := &InsufficientPoolCreationSuite{}
 
-	// Define base flags for random read fallback tests.
-	baseRandomReadFlags := gcsfuseTestFlags{
-		enableBufferedRead:   true,
-		blockSizeMB:          8,
-		maxBlocksPerHandle:   20,
-		startBlocksPerHandle: 2,
-		minBlocksPerHandle:   2,
+	if testEnv.cfg.GKEMountedDirectory != "" && testEnv.cfg.TestBucket != "" {
+		suite.Run(t, ts)
+		return
 	}
 
-	// Run tests for mounted directory if the flag is set.
-	if setup.AreBothMountedDirectoryAndTestBucketFlagsSet() {
-		suite.Run(t, &InsufficientPoolCreationSuite{fallbackSuiteBase{testFlags: &baseInsufficientPoolFlags}})
-		suite.Run(t, &RandomReadFallbackSuite{fallbackSuiteBase{testFlags: &baseRandomReadFlags}})
-		return
+	flagsSet := setup.BuildFlagSets(*testEnv.cfg, testEnv.bucketType, t.Name())
+	for _, ts.flags = range flagsSet {
+		log.Printf("Running tests with flags: %s", ts.flags)
+		suite.Run(t, ts)
 	}
+}
 
-	protocols := []string{clientProtocolHTTP1, clientProtocolGRPC}
+func TestRandomReadFallbackSuite(t *testing.T) {
+	ts := &RandomReadFallbackSuite{}
 
-	for _, protocol := range protocols {
-		t.Run(protocol, func(t *testing.T) {
-			// Run the suite for insufficient pool at creation time.
-			insufficientPoolFlags := baseInsufficientPoolFlags
-			insufficientPoolFlags.clientProtocol = protocol
-			suite.Run(t, &InsufficientPoolCreationSuite{fallbackSuiteBase{testFlags: &insufficientPoolFlags}})
+	if testEnv.cfg.GKEMountedDirectory != "" && testEnv.cfg.TestBucket != "" {
+		suite.Run(t, ts)
+		return
+	}
 
-			// Run the suite for random read fallback scenarios.
-			randomReadFlags := baseRandomReadFlags
-			randomReadFlags.clientProtocol = protocol
-			suite.Run(t, &RandomReadFallbackSuite{fallbackSuiteBase{testFlags: &randomReadFlags}})
-		})
+	flagsSet := setup.BuildFlagSets(*testEnv.cfg, testEnv.bucketType, t.Name())
+	for _, ts.flags = range flagsSet {
+		log.Printf("Running tests with flags: %s", ts.flags)
+		suite.Run(t, ts)
 	}
 }

tools/integration_tests/buffered_read/sequential_read_test.go

@@ -16,6 +16,7 @@ package buffered_read
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"path"
 	"syscall"
@@ -36,38 +37,31 @@ import (
 
 type SequentialReadSuite struct {
 	suite.Suite
-	// Helper struct with test flags.
-	testFlags *gcsfuseTestFlags
+	flags []string
 }
 
 func (s *SequentialReadSuite) SetupSuite() {
 	if setup.MountedDirectory() != "" {
 		setupForMountedDirectoryTests()
 		return
 	}
-	// Create config file.
-	configFile := createConfigFile(s.testFlags)
-	// Create the final flags slice.
-	// The static mounting helper adds --log-file and --log-severity flags, so we only need to add the format.
-	flags := []string{"--config-file=" + configFile}
-	// Mount GCSFuse.
-	setup.MountGCSFuseWithGivenMountFunc(flags, mountFunc)
+	setup.MountGCSFuseWithGivenMountWithConfigFunc(testEnv.cfg, s.flags, mountFunc)
 }
 
 func (s *SequentialReadSuite) TearDownSuite() {
 	if setup.MountedDirectory() != "" {
 		setup.SaveGCSFuseLogFileInCaseOfFailure(s.T())
 		return
 	}
-	setup.UnmountGCSFuse(rootDir)
+	setup.UnmountGCSFuseWithConfig(testEnv.cfg)
 	setup.SaveGCSFuseLogFileInCaseOfFailure(s.T())
 }
 
 // //////////////////////////////////////////////////////////////////////
 // Test Cases
 // //////////////////////////////////////////////////////////////////////
 func (s *SequentialReadSuite) TestSequentialRead() {
-	blockSizeInBytes := s.testFlags.blockSizeMB * util.MiB
+	blockSizeInBytes := int64(8 * util.MiB)
 	fileSizeTests := []struct {
 		name     string
 		fileSize int64
@@ -112,7 +106,7 @@ func (s *SequentialReadSuite) TestSequentialRead() {
 // buffered read log entry, indicating efficient handling.
 func (s *SequentialReadSuite) TestReadHeaderFooterAndBody() {
 	// Constants for block and file sizes
-	blockSizeInBytes := s.testFlags.blockSizeMB * util.MiB
+	blockSizeInBytes := int64(8 * util.MiB)
 	// Header and footer sizes (10KB each)
 	headerSize := 10 * util.KiB
 	footerSize := 10 * util.KiB
@@ -160,7 +154,7 @@ func (s *SequentialReadSuite) TestReadHeaderFooterAndBody() {
 // TestReadSpanningTwoBlocks verifies that a read spanning two buffer blocks is
 // handled correctly.
 func (s *SequentialReadSuite) TestReadSpanningTwoBlocks() {
-	blockSizeInBytes := s.testFlags.blockSizeMB * util.MiB
+	blockSizeInBytes := int64(8 * util.MiB)
 	// Ensure file is large enough for multi-block reads.
 	fileSize := 3 * blockSizeInBytes
 	// We want to read 512KB, with 256KB in the first block and 256KB in the second.
@@ -186,30 +180,16 @@ func (s *SequentialReadSuite) TestReadSpanningTwoBlocks() {
 ////////////////////////////////////////////////////////////////////////
 
 func TestSequentialReadSuite(t *testing.T) {
-	// Define the different flag configurations to test against.
-	baseTestFlags := gcsfuseTestFlags{
-		enableBufferedRead:   true,
-		blockSizeMB:          8,
-		maxBlocksPerHandle:   20,
-		startBlocksPerHandle: 1,
-		minBlocksPerHandle:   2,
-	}
+	ts := &SequentialReadSuite{}
 
-	// Run tests for mounted directory if the flag is set.
-	if setup.AreBothMountedDirectoryAndTestBucketFlagsSet() {
-		suite.Run(t, &SequentialReadSuite{testFlags: &baseTestFlags})
+	if testEnv.cfg.GKEMountedDirectory != "" && testEnv.cfg.TestBucket != "" {
+		suite.Run(t, ts)
 		return
 	}
 
-	protocols := []string{clientProtocolHTTP1, clientProtocolGRPC}
-
-	for _, protocol := range protocols {
-		// Create a new suite for each protocol.
-		t.Run(protocol, func(t *testing.T) {
-			testFlags := baseTestFlags
-			testFlags.clientProtocol = protocol
-
-			suite.Run(t, &SequentialReadSuite{testFlags: &testFlags})
-		})
+	flagsSet := setup.BuildFlagSets(*testEnv.cfg, testEnv.bucketType, t.Name())
+	for _, ts.flags = range flagsSet {
+		log.Printf("Running tests with flags: %s", ts.flags)
+		suite.Run(t, ts)
 	}
 }