func (s *apiclientSuite) TestIsBrokenOk(c *gc.C) {
conn := api.NewTestingState(api.TestingStateParams{
RPCConnection: newRPCConnection(),
Clock: new(fakeClock),
})
c.Assert(conn.IsBroken(), jc.IsFalse)
}
func (s *apiclientSuite) TestAPICallRetriesLimit(c *gc.C) {
clock := &fakeClock{}
retryError := errors.Trace(&rpc.RequestError{Message: "hmm...", Code: params.CodeRetry})
var errors []error
for i := 0; i < 10; i++ {
errors = append(errors, retryError)
}
conn := api.NewTestingState(api.TestingStateParams{
RPCConnection: &fakeRPCConnection{
errors: errors,
},
Clock: clock,
})
err := conn.APICall("facade", 1, "id", "method", nil, nil)
c.Check(err, jc.Satisfies, retry.IsDurationExceeded)
c.Check(err, gc.ErrorMatches, `.*hmm... \(retry\)`)
c.Check(clock.waits, jc.DeepEquals, []time.Duration{
100 * time.Millisecond,
200 * time.Millisecond,
400 * time.Millisecond,
800 * time.Millisecond,
1500 * time.Millisecond,
1500 * time.Millisecond,
1500 * time.Millisecond,
1500 * time.Millisecond,
1500 * time.Millisecond,
})
}
func (s *apiclientSuite) TestIsBrokenPingFailed(c *gc.C) {
conn := api.NewTestingState(api.TestingStateParams{
RPCConnection: newRPCConnection(errors.New("no biscuit")),
Clock: new(fakeClock),
})
c.Assert(conn.IsBroken(), jc.IsTrue)
}
func (s *facadeVersionSuite) TestBestFacadeVersionNewerClient(c *gc.C) {
s.PatchValue(api.FacadeVersions, map[string]int{"Client": 2})
st := api.NewTestingState(api.TestingStateParams{
FacadeVersions: map[string][]int{
"Client": []int{0, 1},
}})
c.Check(st.BestFacadeVersion("Client"), gc.Equals, 1)
}
func (s *facadeVersionSuite) TestBestFacadeVersionServerUnknown(c *gc.C) {
s.PatchValue(api.FacadeVersions, map[string]int{"TestingAPI": 2})
st := api.NewTestingState(api.TestingStateParams{
FacadeVersions: map[string][]int{
"Client": {0, 1},
}})
c.Check(st.BestFacadeVersion("TestingAPI"), gc.Equals, 0)
}
func (s *apiclientSuite) TestIsBrokenChannelClosed(c *gc.C) {
broken := make(chan struct{})
close(broken)
conn := api.NewTestingState(api.TestingStateParams{
RPCConnection: newRPCConnection(),
Clock: new(fakeClock),
Broken: broken,
})
c.Assert(conn.IsBroken(), jc.IsTrue)
}
func (s *apiclientSuite) TestAPICallNoError(c *gc.C) {
clock := &fakeClock{}
conn := api.NewTestingState(api.TestingStateParams{
RPCConnection: &fakeRPCConnection{},
Clock: clock,
})
err := conn.APICall("facade", 1, "id", "method", nil, nil)
c.Check(err, jc.ErrorIsNil)
c.Check(clock.waits, gc.HasLen, 0)
}
func (s *apiclientSuite) TestAPICallError(c *gc.C) {
clock := &fakeClock{}
conn := api.NewTestingState(api.TestingStateParams{
RPCConnection: newRPCConnection(errors.BadRequestf("boom")),
Clock: clock,
})
err := conn.APICall("facade", 1, "id", "method", nil, nil)
c.Check(err.Error(), gc.Equals, "boom")
c.Check(err, jc.Satisfies, errors.IsBadRequest)
c.Check(clock.waits, gc.HasLen, 0)
}
func (s *apiclientSuite) TestPing(c *gc.C) {
clock := &fakeClock{}
rpcConn := newRPCConnection()
conn := api.NewTestingState(api.TestingStateParams{
RPCConnection: rpcConn,
Clock: clock,
})
err := conn.Ping()
c.Assert(err, jc.ErrorIsNil)
rpcConn.stub.CheckCalls(c, []testing.StubCall{{
"Pinger.Ping", []interface{}{0, nil},
}})
}
func (s *apiclientSuite) TestAPICallRetries(c *gc.C) {
clock := &fakeClock{}
conn := api.NewTestingState(api.TestingStateParams{
RPCConnection: newRPCConnection(
errors.Trace(
&rpc.RequestError{
Message: "hmm...",
Code: params.CodeRetry,
}),
),
Clock: clock,
})
err := conn.APICall("facade", 1, "id", "method", nil, nil)
c.Check(err, jc.ErrorIsNil)
c.Check(clock.waits, jc.DeepEquals, []time.Duration{100 * time.Millisecond})
}
