github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/api/logsender/logsender_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package logsender_test
     5  
     6  import (
     7  	"errors"
     8  	"net/url"
     9  
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/api/base"
    13  	"github.com/juju/juju/api/logsender"
    14  	"github.com/juju/juju/apiserver/params"
    15  	coretesting "github.com/juju/juju/testing"
    16  )
    17  
    18  type LogSenderSuite struct {
    19  	coretesting.BaseSuite
    20  }
    21  
    22  var _ = gc.Suite(&LogSenderSuite{})
    23  
    24  func (s *LogSenderSuite) TestNewAPI(c *gc.C) {
    25  	conn := &mockConnector{
    26  		c: c,
    27  	}
    28  	a := logsender.NewAPI(conn)
    29  	w, err := a.LogWriter()
    30  	c.Assert(err, gc.IsNil)
    31  
    32  	msg := new(params.LogRecord)
    33  	err = w.WriteLog(msg)
    34  	c.Assert(err, gc.IsNil)
    35  
    36  	c.Assert(conn.written, gc.HasLen, 1)
    37  	c.Assert(conn.written[0], gc.Equals, msg)
    38  
    39  	err = w.Close()
    40  	c.Assert(err, gc.IsNil)
    41  	c.Assert(conn.closeCount, gc.Equals, 1)
    42  }
    43  
    44  func (s *LogSenderSuite) TestNewAPIWriteLogError(c *gc.C) {
    45  	conn := &mockConnector{
    46  		c:            c,
    47  		connectError: errors.New("foo"),
    48  	}
    49  	a := logsender.NewAPI(conn)
    50  	w, err := a.LogWriter()
    51  	c.Assert(err, gc.ErrorMatches, "cannot connect to /logsink: foo")
    52  	c.Assert(w, gc.Equals, nil)
    53  }
    54  
    55  func (s *LogSenderSuite) TestNewAPIWriteError(c *gc.C) {
    56  	conn := &mockConnector{
    57  		c:          c,
    58  		writeError: errors.New("foo"),
    59  	}
    60  	a := logsender.NewAPI(conn)
    61  	w, err := a.LogWriter()
    62  	c.Assert(err, gc.IsNil)
    63  
    64  	err = w.WriteLog(new(params.LogRecord))
    65  	c.Assert(err, gc.ErrorMatches, "cannot send log message: foo")
    66  	c.Assert(conn.written, gc.HasLen, 0)
    67  }
    68  
    69  type mockConnector struct {
    70  	c *gc.C
    71  
    72  	connectError error
    73  	writeError   error
    74  	written      []interface{}
    75  
    76  	closeCount int
    77  }
    78  
    79  func (c *mockConnector) ConnectStream(path string, values url.Values) (base.Stream, error) {
    80  	c.c.Assert(path, gc.Equals, "/logsink")
    81  	c.c.Assert(values, gc.HasLen, 0)
    82  	if c.connectError != nil {
    83  		return nil, c.connectError
    84  	}
    85  	return mockStream{c}, nil
    86  }
    87  
    88  type mockStream struct {
    89  	conn *mockConnector
    90  }
    91  
    92  func (s mockStream) WriteJSON(v interface{}) error {
    93  	if s.conn.writeError != nil {
    94  		return s.conn.writeError
    95  	}
    96  	s.conn.written = append(s.conn.written, v)
    97  	return nil
    98  }
    99  
   100  func (s mockStream) ReadJSON(v interface{}) error {
   101  	s.conn.c.Errorf("ReadJSON called unexpectedly")
   102  	return nil
   103  }
   104  
   105  func (s mockStream) Read([]byte) (int, error) {
   106  	s.conn.c.Errorf("Read called unexpectedly")
   107  	return 0, nil
   108  }
   109  
   110  func (s mockStream) Write([]byte) (int, error) {
   111  	s.conn.c.Errorf("Write called unexpectedly")
   112  	return 0, nil
   113  }
   114  
   115  func (s mockStream) Close() error {
   116  	s.conn.closeCount++
   117  	return nil
   118  }