// agentRPCTestIsTimeoutErrorDialExpiredContext verifies that // client.IsTimeoutError() returns true for RPCs failed due to an expired // context before .Dial(). func agentRPCTestIsTimeoutErrorDialExpiredContext(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, ti *topo.TabletInfo) { // Using a timeout of 0 here such that .Dial() will fail immediately. expiredCtx, cancel := context.WithTimeout(ctx, 0) defer cancel() err := client.Ping(expiredCtx, ti) if err == nil { t.Fatal("agentRPCTestIsTimeoutErrorDialExpiredContext: RPC with expired context did not fail") } if !client.IsTimeoutError(err) { t.Errorf("agentRPCTestIsTimeoutErrorDialExpiredContext: want: IsTimeoutError() = true. error: %v", err) } }
// agentRPCTestIsTimeoutErrorDialTimeout verifies that client.IsTimeoutError() // returns true for RPCs failed due to a connect timeout during .Dial(). func agentRPCTestIsTimeoutErrorDialTimeout(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, ti *topo.TabletInfo) { // Connect to a non-existing tablet. // For example, this provokes gRPC to return error grpc.ErrClientConnTimeout. invalidTi := topo.NewTabletInfo(ti.Tablet, ti.Version()) invalidTi.Tablet = proto.Clone(invalidTi.Tablet).(*topodatapb.Tablet) invalidTi.Tablet.Hostname = "Non-Existent.Server" shortCtx, cancel := context.WithTimeout(ctx, time.Millisecond) defer cancel() err := client.Ping(shortCtx, invalidTi) if err == nil { t.Fatal("agentRPCTestIsTimeoutErrorDialTimeout: connect to non-existant tablet did not fail") } if !client.IsTimeoutError(err) { t.Errorf("agentRPCTestIsTimeoutErrorDialTimeout: want: IsTimeoutError() = true. error: %v", err) } }
// agentRPCTestDialExpiredContext verifies that // the context returns the right DeadlineExceeded Err() for // RPCs failed due to an expired context before .Dial(). func agentRPCTestDialExpiredContext(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, tablet *topodatapb.Tablet) { // Using a timeout of 0 here such that .Dial() will fail immediately. expiredCtx, cancel := context.WithTimeout(ctx, 0) defer cancel() err := client.Ping(expiredCtx, tablet) if err == nil { t.Fatal("agentRPCTestDialExpiredContext: RPC with expired context did not fail") } // The context was already expired when we created it. Here we only verify that it returns the expected error. select { case <-expiredCtx.Done(): if err := expiredCtx.Err(); err != context.DeadlineExceeded { t.Errorf("agentRPCTestDialExpiredContext: got %v want context.DeadlineExceeded", err) } default: t.Errorf("agentRPCTestDialExpiredContext: context.Done() not closed") } }
// agentRPCTestIsTimeoutErrorRPC verifies that client.IsTimeoutError() returns // true for RPCs failed due to an expired context during RPC execution. func agentRPCTestIsTimeoutErrorRPC(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, ti *topo.TabletInfo, fakeAgent *fakeRPCAgent) { // We must use a timeout > 0 such that the context deadline hasn't expired // yet in grpctmclient.Client.dial(). // NOTE: This might still race e.g. when test execution takes too long the // context will be expired in dial() already. In such cases coverage // will be reduced but the test will not flake. shortCtx, cancel := context.WithTimeout(ctx, time.Millisecond) defer cancel() fakeAgent.slow = true defer func() { fakeAgent.slow = false }() err := client.Ping(shortCtx, ti) if err == nil { t.Fatal("agentRPCTestIsTimeoutErrorRPC: RPC with expired context did not fail") } if !client.IsTimeoutError(err) { t.Errorf("agentRPCTestIsTimeoutErrorRPC: want: IsTimeoutError() = true. error: %v", err) } }
// agentRPCTestRPCTimeout verifies that // the context returns the right DeadlineExceeded Err() for // RPCs failed due to an expired context during execution. func agentRPCTestRPCTimeout(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, tablet *topodatapb.Tablet, fakeAgent *fakeRPCAgent) { // We must use a timeout > 0 such that the context deadline hasn't expired // yet in grpctmclient.Client.dial(). // NOTE: This might still race e.g. when test execution takes too long the // context will be expired in dial() already. In such cases coverage // will be reduced but the test will not flake. shortCtx, cancel := context.WithTimeout(ctx, 10*time.Millisecond) defer cancel() fakeAgent.setSlow(true) defer func() { fakeAgent.setSlow(false) }() err := client.Ping(shortCtx, tablet) if err == nil { t.Fatal("agentRPCTestRPCTimeout: RPC with expired context did not fail") } select { case <-shortCtx.Done(): if err := shortCtx.Err(); err != context.DeadlineExceeded { t.Errorf("agentRPCTestRPCTimeout: got %v want context.DeadlineExceeded", err) } default: t.Errorf("agentRPCTestRPCTimeout: context.Done() not closed") } }
func agentRPCTestPingPanic(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, tablet *topodatapb.Tablet) { err := client.Ping(ctx, tablet) expectRPCWrapPanic(t, err) }
func agentRPCTestPing(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, tablet *topodatapb.Tablet) { err := client.Ping(ctx, tablet) if err != nil { t.Errorf("Ping failed: %v", err) } }
func agentRPCTestPingPanic(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, tablet *topodatapb.Tablet) { err := client.Ping(ctx, tablet) expectHandleRPCPanic(t, "Ping", false /*verbose*/, err) }
func agentRpcTestPing(t *testing.T, client tmclient.TabletManagerClient, ti *topo.TabletInfo) { err := client.Ping(ti, time.Minute) if err != nil { t.Errorf("Ping failed: %v", err) } }