Function TestActivePartitionBatchRing_Get

ring/partition_ring_test.go:1213–1262

(t *testing.T)

}

func TestActivePartitionBatchRing_Get(t *testing.T) {
	const numRuns = 1000

	ring := createPartitionRingWithPartitions(DefaultPartitionRingOptions(), 10, 5, 5)
	activeRing := NewActivePartitionBatchRing(ring)
	buf := [GetBufferSize]InstanceDesc{}

	t.Run("should return a ReplicationSet with the active partition owning the input key", func(t *testing.T) {
		for _, withBuffer := range []bool{true, false} {
			t.Run(fmt.Sprintf("buffer: %t", withBuffer), func(t *testing.T) {
				// Randomise the seed but log it in case we need to reproduce the test on failure.
				seed := time.Now().UnixNano()
				rnd := rand.New(rand.NewSource(seed))
				t.Log("random generator seed:", seed)

				var getBuf []InstanceDesc
				if withBuffer {
					getBuf = buf[:0]
				}

				for i := 0; i < numRuns; i++ {
					key := uint32(rnd.Intn(math.MaxUint32))
					expected, err := ring.ActivePartitionForKey(key)
					require.NoError(t, err)

					actual, err := activeRing.Get(key, WriteNoExtend, getBuf, nil, nil)
					require.NoError(t, err)

					require.Len(t, actual.Instances, 1)
					assert.Equal(t, strconv.Itoa(int(expected)), actual.Instances[0].Id)
					assert.Equal(t, strconv.Itoa(int(expected)), actual.Instances[0].Addr)
					assert.Equal(t, 0, actual.MaxErrors)
					assert.Equal(t, 0, actual.MaxUnavailableZones)
					assert.False(t, actual.ZoneAwarenessEnabled)
				}
			})
		}
	})

	t.Run("should not allocate memory with buffer is provided", func(t *testing.T) {
		allocs := testing.AllocsPerRun(numRuns, func() {
			_, err := activeRing.Get(12345, WriteNoExtend, buf[:0], nil, nil)
			if err != nil {
				t.Fatal(err)
			}
		})

		require.Equal(t, 0.0, allocs)
	})
}

func BenchmarkActivePartitionBatchRing_Get(b *testing.B) {
	benchCases := map[string]struct {