Function TestGetOrCreate

pkg/cache/filecache_test.go:154–230

(t *testing.T)

}

func TestGetOrCreate(t *testing.T) {
	zerolog.TimeFieldFormat = time.RFC3339
	//c := New(zerolog.New(os.Stdout).With().Timestamp().Logger().WithContext(context.Background()))
	c := NewCache(context.Background(), cacheBlockSize, testFileCachePath)
	var eg errgroup.Group

	fileNames := new(sync.Map)
	fileContents := new(sync.Map)
	fileSizes := new(sync.Map)

	for i := 0; i < 100; i++ {

		fileNames.Store(i, newRandomStringN(10))
		b := []byte(newRandomString())
		size := int64(len(b))
		fileContents.Store(i, b)
		fileSizes.Store(i, size)

		for j := 0; j < 10; j++ {
			segs, err := math.NewSegments(0, 1024*1024, size, size)
			if err != nil {
				t.Fatal(err)
			}
			for seg := range segs.All() {

				s := seg
				fileIndex := i

				eg.Go(func() error {
					offset := s.Index
					count := s.Count
					fc, ok := fileContents.Load(fileIndex)
					if !ok {
						t.Fatalf("could not load fileContent from sync map: %v", fileIndex)
					}
					fcBytes, _ := fc.([]byte)
					expected := make([]byte, count)
					copy(expected, fcBytes[offset:offset+int64(count)])

					fn, ok := fileNames.Load(fileIndex)
					if !ok {
						t.Fatalf("could not load fileName from sync map: %v", fileIndex)
					}
					name, _ := fn.(string)

					got, err := c.GetOrCreate(name, offset, count, func() ([]byte, error) {
						return expected, nil
					})
					if err != nil {
						return fmt.Errorf("failed to get or create: %v -- %v", name, err)
					}

					l := len(got)
					if count != l {
						return fmt.Errorf("size mismatch, expected %v, got %v, offset: %v, fileName: %v", count, len(got), offset, name)
					}

					validationLen := math.Min(100, count)