Method TestMaxCallAttempts

test/retry_test.go:500–602

(t *testing.T)

}

func (s) TestMaxCallAttempts(t *testing.T) {
	testCases := []struct {
		serviceMaxAttempts int
		clientMaxAttempts  int
		expectedAttempts   int
	}{
		{serviceMaxAttempts: 9, clientMaxAttempts: 4, expectedAttempts: 4},
		{serviceMaxAttempts: 9, clientMaxAttempts: 7, expectedAttempts: 7},
		{serviceMaxAttempts: 3, clientMaxAttempts: 10, expectedAttempts: 3},
		{serviceMaxAttempts: 8, clientMaxAttempts: -1, expectedAttempts: 5}, // 5 is default max
		{serviceMaxAttempts: 3, clientMaxAttempts: 0, expectedAttempts: 3},
	}

	for _, tc := range testCases {
		clientOpts := []grpc.DialOption{
			grpc.WithMaxCallAttempts(tc.clientMaxAttempts),
			grpc.WithDefaultServiceConfig(fmt.Sprintf(`{
				"methodConfig": [{
					"name": [{"service": "grpc.testing.TestService"}],
					"waitForReady": true,
					"retryPolicy": {
						"MaxAttempts": %d,
						"InitialBackoff": ".01s",
						"MaxBackoff": ".01s",
						"BackoffMultiplier": 1.0,
						"RetryableStatusCodes": [ "UNAVAILABLE" ]
					}
					}]}`, tc.serviceMaxAttempts),
			),
		}

		serverMu := sync.Mutex{}
		streamCallCount := 0
		unaryCallCount := 0

		ss := &stubserver.StubServer{
			FullDuplexCallF: func(testgrpc.TestService_FullDuplexCallServer) error {
				serverMu.Lock()
				defer serverMu.Unlock()
				streamCallCount++
				return status.New(codes.Unavailable, "this is a test error").Err()
			},
			EmptyCallF: func(context.Context, *testpb.Empty) (r *testpb.Empty, err error) {
				serverMu.Lock()
				defer serverMu.Unlock()
				unaryCallCount++
				return nil, status.New(codes.Unavailable, "this is a test error").Err()
			},
		}

		func() {

			if err := ss.Start([]grpc.ServerOption{}, clientOpts...); err != nil {
				t.Fatalf("Error starting endpoint server: %v", err)
			}
			defer ss.Stop()
			ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
			defer cancel()