func TestInitialAdvertiseFailedRetryTimeout(t *testing.T) {
timeSleep = func(d time.Duration) {}
defer testutils.ResetSleepStub(&timeSleep)
withSetup(t, func(hypCh *tchannel.Channel, hyperbahnHostPort string) {
started := time.Now()
count := 0
adHandler := func(ctx json.Context, req *AdRequest) (*AdResponse, error) {
count++
deadline, ok := ctx.Deadline()
if assert.True(t, ok, "context is missing Deadline") {
assert.True(t, deadline.Sub(started) <= 2*time.Second,
"Timeout per attempt should be 1 second. Started: %v Deadline: %v", started, deadline)
}
return nil, tchannel.NewSystemError(tchannel.ErrCodeUnexpected, "unexpected")
}
json.Register(hypCh, json.Handlers{"ad": adHandler}, nil)
ch := testutils.NewServer(t, nil)
client, err := NewClient(ch, configFor(hyperbahnHostPort), nil)
assert.NoError(t, err, "hyperbahn NewClient failed")
defer client.Close()
assert.Error(t, client.Advertise(), "Advertise should not succeed")
// We expect 5 retries by TChannel and we attempt 5 to advertise 5 times.
assert.Equal(t, 5*5, count, "adHandler not retried correct number of times")
})
}
func runRetryTest(t *testing.T, f func(r *retryTest)) {
r := &retryTest{}
defer testutils.SetTimeout(t, time.Second)()
r.setup()
defer testutils.ResetSleepStub(&timeSleep)
withSetup(t, func(hypCh *tchannel.Channel, hostPort string) {
json.Register(hypCh, json.Handlers{"ad": r.adHandler}, nil)
// Advertise failures cause warning log messages.
opts := testutils.NewOpts().
SetServiceName("my-client").
AddLogFilter("Hyperbahn client registration failed", 10)
serverCh := testutils.NewServer(t, opts)
defer serverCh.Close()
var err error
r.ch = serverCh
r.client, err = NewClient(serverCh, configFor(hostPort), &ClientOptions{
Handler: r,
FailStrategy: FailStrategyIgnore,
})
require.NoError(t, err, "NewClient")
defer r.client.Close()
f(r)
r.mock.AssertExpectations(t)
})
}
func TestInitialAdvertiseFailedRetryBackoff(t *testing.T) {
defer testutils.SetTimeout(t, time.Second)()
sleepArgs, sleepBlock, sleepClose := testutils.SleepStub(&timeSleep)
defer testutils.ResetSleepStub(&timeSleep)
// We expect to retry 5 times,
go func() {
for attempt := uint(0); attempt < 5; attempt++ {
maxSleepFor := advertiseRetryInterval * time.Duration(1<<attempt)
got := <-sleepArgs
assert.True(t, got <= maxSleepFor,
"Initial advertise attempt %v expected sleep %v < %v", attempt, got, maxSleepFor)
sleepBlock <- struct{}{}
}
sleepClose()
}()
withSetup(t, func(hypCh *tchannel.Channel, hostPort string) {
serverCh := testutils.NewServer(t, nil)
defer serverCh.Close()
client, err := NewClient(serverCh, configFor(hostPort), nil)
require.NoError(t, err, "NewClient")
defer client.Close()
assert.Error(t, client.Advertise(), "Advertise without handler should fail")
})
}
func runRetryTest(t *testing.T, f func(r *retryTest)) {
r := &retryTest{}
defer testutils.SetTimeout(t, time.Second)()
r.setup()
defer testutils.ResetSleepStub(&timeSleep)
withSetup(t, func(serverCh *tchannel.Channel, hostPort string) {
json.Register(serverCh, json.Handlers{"ad": r.adHandler}, nil)
clientCh, err := testutils.NewServer(&testutils.ChannelOpts{ServiceName: "my-client"})
require.NoError(t, err, "NewServer failed")
defer clientCh.Close()
r.ch = clientCh
r.client, err = NewClient(clientCh, configFor(hostPort), &ClientOptions{
Handler: r,
FailStrategy: FailStrategyIgnore,
})
require.NoError(t, err, "NewClient")
defer r.client.Close()
f(r)
r.mock.AssertExpectations(t)
})
}