Function TestRing_ShuffleShardWithLookback_CorrectnessWithFuzzy

ring/ring_test.go:2809–3000

This test asserts that for some randomly generated history of shuffleShard (without lookback) results, every subsequent ShuffleShardWithLookback will be a superset of all previously recorded shuffleShards.

(t *testing.T)

// This test asserts that for some randomly generated history of shuffleShard (without lookback) results,
// every subsequent ShuffleShardWithLookback will be a superset of all previously recorded shuffleShards.
func TestRing_ShuffleShardWithLookback_CorrectnessWithFuzzy(t *testing.T) {
	// The goal of this test is NOT to ensure that the minimum required number of instances
	// are returned at any given time, BUT at least all required instances are returned.
	var (
		numInitialInstances = []int{9, 30, 60, 90}
		numInitialZones     = []int{1, 3}
		numEvents           = 100
		lookbackPeriod      = time.Hour
		delayBetweenEvents  = 5 * time.Minute // 12 events / hour
		userID              = "user-1"
	)

	for _, updateOldestRegisteredTimestamp := range []bool{false, true} {
		updateOldestRegisteredTimestamp := updateOldestRegisteredTimestamp

		for _, updateReadOnlyInstances := range []bool{false, true} {
			updateReadOnlyInstances := updateReadOnlyInstances

			for _, numInstances := range numInitialInstances {
				numInstances := numInstances

				for _, numZones := range numInitialZones {
					numZones := numZones

					testName := fmt.Sprintf("num instances = %d, num zones = %d, update oldest registered timestamp = %v, update read only instances = %v", numInstances, numZones, updateOldestRegisteredTimestamp, updateReadOnlyInstances)

					t.Run(testName, func(t *testing.T) {
						t.Parallel()

						// 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)
						gen := NewRandomTokenGeneratorWithSeed(seed)

						// Initialise the ring.
						ringDesc := &Desc{Ingesters: generateRingInstances(gen, numInstances, numZones, 128)}
						ring := newRingForTesting(Config{
							HeartbeatTimeout:     time.Hour,
							ZoneAwarenessEnabled: true,
							ReplicationFactor:    3,
						}, false)

						updateRing := func() {
							ring.setRingStateFromDesc(ringDesc, false, updateOldestRegisteredTimestamp, updateReadOnlyInstances)

							if len(ring.ringZones) != numZones {
								t.Fatalf("number of zones changed, original=%d, current zones=%v", numZones, ring.ringZones)
							}
						}
						updateRing()

						// The simulation starts with the minimum shard size. Random events can later increase it.
						shardSize := numZones

						// The simulation assumes the initial ring contains instances registered
						// since more than the lookback period.
						currTime := time.Now().Add(lookbackPeriod).Add(time.Minute)