func()

in registry/storage/driver/testsuites/testsuites.go [2269:2371]
79 lines of code
10 McCabe index (conditional complexity)

func (s *DriverSuite) TestWalk() {
	rootDirectory := "/" + dtestutil.RandomFilenameRange(8, 8)
	defer s.deletePath(s.StorageDriver, rootDirectory)
	s.T().Logf("root directory used for testing: %s", rootDirectory)

	numWantedFiles := 10
	wantedFiles := dtestutil.RandomBranchingFiles(rootDirectory, numWantedFiles)
	wantedDirectoriesSet := make(map[string]struct{})

	for i := 0; i < numWantedFiles; i++ {
		// Gather unique directories from the full path, excluding the root directory.
		p := path.Dir(wantedFiles[i])
		for {
			// Guard against non-terminating loops: path.Dir returns "." if the path is empty.
			if p == rootDirectory || p == "." {
				break
			}
			wantedDirectoriesSet[p] = struct{}{}
			p = path.Dir(p)
		}

		/* #nosec G404 */
		err := s.StorageDriver.PutContent(s.ctx, wantedFiles[i], s.blobberFactory.GetBlobber(8+mrand.Int64N(8)).GetAllBytes())
		require.NoError(s.T(), err)
	}

	verifyResults := func(actualFiles, actualDirectories []string) {
		require.ElementsMatch(s.T(), wantedFiles, actualFiles)

		// Convert from a set of wanted directories into a slice.
		wantedDirectories := make([]string, len(wantedDirectoriesSet))

		var i int
		for k := range wantedDirectoriesSet {
			wantedDirectories[i] = k
			i++
		}

		require.ElementsMatch(s.T(), wantedDirectories, actualDirectories)
	}

	s.Run("PararellWalk", func() {
		s.skipIfWalkParallelIsNotSupported()

		fChan := make(chan string)
		dChan := make(chan string)

		var actualFiles []string
		var actualDirectories []string

		var wg sync.WaitGroup

		go func() {
			defer wg.Done()
			wg.Add(1)
			for f := range fChan {
				actualFiles = append(actualFiles, f)
			}
		}()
		go func() {
			defer wg.Done()
			wg.Add(1)
			for d := range dChan {
				actualDirectories = append(actualDirectories, d)
			}
		}()

		err := s.StorageDriver.WalkParallel(s.ctx, rootDirectory, func(fInfo storagedriver.FileInfo) error {
			// Use append here to prevent a panic if walk finds more than we expect.
			if fInfo.IsDir() {
				dChan <- fInfo.Path()
			} else {
				fChan <- fInfo.Path()
			}
			return nil
		})
		require.NoError(s.T(), err)

		close(fChan)
		close(dChan)

		wg.Wait()

		verifyResults(actualFiles, actualDirectories)
	})

	s.Run("PlainWalk", func() {
		var actualFiles []string
		var actualDirectories []string

		err := s.StorageDriver.Walk(s.ctx, rootDirectory, func(fInfo storagedriver.FileInfo) error {
			if fInfo.IsDir() {
				actualDirectories = append(actualDirectories, fInfo.Path())
			} else {
				actualFiles = append(actualFiles, fInfo.Path())
			}
			return nil
		})

		require.NoError(s.T(), err)
		verifyResults(actualFiles, actualDirectories)
	})
}