func (*suite) TestWriteMessageLogsRequests(c *gc.C) {
codecLogger := loggo.GetLogger("juju.rpc.jsoncodec")
defer codecLogger.SetLogLevel(codecLogger.LogLevel())
codecLogger.SetLogLevel(loggo.TRACE)
codec := jsoncodec.New(&testConn{})
h := rpc.Header{
RequestId: 1,
Request: rpc.Request{
Type: "foo",
Id: "id",
Action: "frob",
},
}
// Check that logging is off by default
err := codec.WriteMessage(&h, value{X: "param"})
c.Assert(err, gc.IsNil)
c.Assert(c.GetTestLog(), gc.Matches, "")
// Check that we see a log message when we switch logging on.
codec.SetLogging(true)
err = codec.WriteMessage(&h, value{X: "param"})
c.Assert(err, gc.IsNil)
msg := `{"RequestId":1,"Type":"foo","Id":"id","Request":"frob","Params":{"X":"param"}}`
c.Assert(c.GetTestLog(), gc.Matches, `.*TRACE juju.rpc.jsoncodec -> `+regexp.QuoteMeta(msg)+`\n`)
// Check that we can switch it off again
codec.SetLogging(false)
err = codec.WriteMessage(&h, value{X: "param"})
c.Assert(err, gc.IsNil)
c.Assert(c.GetTestLog(), gc.Matches, `.*TRACE juju.rpc.jsoncodec -> `+regexp.QuoteMeta(msg)+`\n`)
}
func (*suite) TestReadHeaderLogsRequests(c *gc.C) {
codecLogger := loggo.GetLogger("juju.rpc.jsoncodec")
defer codecLogger.SetLogLevel(codecLogger.LogLevel())
codecLogger.SetLogLevel(loggo.TRACE)
msg := `{"RequestId":1,"Type": "foo","Id": "id","Request":"frob","Params":{"X":"param"}}`
codec := jsoncodec.New(&testConn{
readMsgs: []string{msg, msg, msg},
})
// Check that logging is off by default
var h rpc.Header
err := codec.ReadHeader(&h)
c.Assert(err, gc.IsNil)
c.Assert(c.GetTestLog(), gc.Matches, "")
// Check that we see a log message when we switch logging on.
codec.SetLogging(true)
err = codec.ReadHeader(&h)
c.Assert(err, gc.IsNil)
c.Assert(c.GetTestLog(), gc.Matches, ".*TRACE juju.rpc.jsoncodec <- "+regexp.QuoteMeta(msg)+`\n`)
// Check that we can switch it off again
codec.SetLogging(false)
err = codec.ReadHeader(&h)
c.Assert(err, gc.IsNil)
c.Assert(c.GetTestLog(), gc.Matches, ".*TRACE juju.rpc.jsoncodec <- "+regexp.QuoteMeta(msg)+`\n`)
}
func (*suite) TestWrite(c *gc.C) {
for i, test := range writeTests {
c.Logf("test %d", i)
var conn testConn
codec := jsoncodec.New(&conn)
err := codec.WriteMessage(test.hdr, test.body)
c.Assert(err, gc.IsNil)
c.Assert(conn.writeMsgs, gc.HasLen, 1)
assertJSONEqual(c, conn.writeMsgs[0], test.expect)
}
}
func (*suite) TestErrorAfterClose(c *gc.C) {
conn := &testConn{
err: errors.New("some error"),
}
codec := jsoncodec.New(conn)
var hdr rpc.Header
err := codec.ReadHeader(&hdr)
c.Assert(err, gc.ErrorMatches, "error receiving message: some error")
err = codec.Close()
c.Assert(err, gc.IsNil)
c.Assert(conn.closed, gc.Equals, true)
err = codec.ReadHeader(&hdr)
c.Assert(err, gc.Equals, io.EOF)
}
func (*suite) TestConcurrentSetLoggingAndRead(c *gc.C) {
// If log messages are not set atomically, this
// test will fail when run under the race detector.
msg := `{"RequestId":1,"Type": "foo","Id": "id","Request":"frob","Params":{"X":"param"}}`
codec := jsoncodec.New(&testConn{
readMsgs: []string{msg, msg, msg},
})
done := make(chan struct{})
go func() {
codec.SetLogging(true)
done <- struct{}{}
}()
var h rpc.Header
err := codec.ReadHeader(&h)
c.Assert(err, gc.IsNil)
<-done
}
func (*suite) TestConcurrentSetLoggingAndWrite(c *gc.C) {
// If log messages are not set atomically, this
// test will fail when run under the race detector.
codec := jsoncodec.New(&testConn{})
done := make(chan struct{})
go func() {
codec.SetLogging(true)
done <- struct{}{}
}()
h := rpc.Header{
RequestId: 1,
Request: rpc.Request{
Type: "foo",
Id: "id",
Action: "frob",
},
}
err := codec.WriteMessage(&h, value{X: "param"})
c.Assert(err, gc.IsNil)
<-done
}
func (*suite) TestRead(c *gc.C) {
for i, test := range readTests {
c.Logf("test %d", i)
codec := jsoncodec.New(&testConn{
readMsgs: []string{test.msg},
})
var hdr rpc.Header
err := codec.ReadHeader(&hdr)
c.Assert(err, gc.IsNil)
c.Assert(hdr, gc.DeepEquals, test.expectHdr)
c.Assert(hdr.IsRequest(), gc.Equals, test.expectHdr.IsRequest())
body := reflect.New(reflect.ValueOf(test.expectBody).Type().Elem()).Interface()
err = codec.ReadBody(body, test.expectHdr.IsRequest())
c.Assert(err, gc.IsNil)
c.Assert(body, gc.DeepEquals, test.expectBody)
err = codec.ReadHeader(&hdr)
c.Assert(err, gc.Equals, io.EOF)
}
}