Function TestApply

loadbalancer/algorithm_test.go:228–296

(t *testing.T)

}

func TestApply(t *testing.T) {
	const R = 1000
	const N = 10
	eps := make([]string, 0, N)
	for i := 0; i < N; i++ {
		ep := fmt.Sprintf("http://127.0.0.1:123%d/foo", i)
		eps = append(eps, ep)
	}

	for _, tt := range []struct {
		name          string
		expected      int
		algorithm     routing.LBAlgorithm
		algorithmName string
	}{
		{
			name:          "random algorithm",
			expected:      N,
			algorithm:     newRandom(eps),
			algorithmName: "random",
		}, {
			name:          "roundrobin algorithm",
			expected:      N,
			algorithm:     newRoundRobin(eps),
			algorithmName: "roundRobin",
		}, {
			name:          "consistentHash algorithm",
			expected:      1,
			algorithm:     newConsistentHash(eps),
			algorithmName: "consistentHash",
		}, {
			name:          "powerOfRandomNChoices algorithm",
			expected:      N,
			algorithm:     newPowerOfRandomNChoices(eps),
			algorithmName: "powerOfRandomNChoices",
		}} {
		t.Run(tt.name, func(t *testing.T) {
			req, _ := http.NewRequest("GET", "http://127.0.0.1:1234/foo", nil)
			p := NewAlgorithmProvider()
			endpointRegistry := routing.NewEndpointRegistry(routing.RegistryOptions{})
			defer endpointRegistry.Close()
			r := &routing.Route{
				Route: eskip.Route{
					BackendType: eskip.LBBackend,
					LBAlgorithm: tt.algorithmName,
					LBEndpoints: eskip.NewLBEndpoints(eps),
				},
			}
			rt := p.Do([]*routing.Route{r})
			endpointRegistry.Do([]*routing.Route{r})

			lbctx := &routing.LBContext{
				Request:     req,
				Route:       rt[0],
				LBEndpoints: rt[0].LBEndpoints,
			}

			h := make(map[string]int)