github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/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  	"io"
     9  	"net/url"
    10  	"time"
    11  
    12  	jc "github.com/juju/testing/checkers"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/api/base"
    16  	"github.com/juju/juju/api/logsender"
    17  	"github.com/juju/juju/apiserver/params"
    18  	coretesting "github.com/juju/juju/testing"
    19  	"github.com/juju/juju/version"
    20  )
    21  
    22  type LogSenderSuite struct {
    23  	coretesting.BaseSuite
    24  }
    25  
    26  var _ = gc.Suite(&LogSenderSuite{})
    27  
    28  func (s *LogSenderSuite) TestNewAPI(c *gc.C) {
    29  	conn := &mockConnector{
    30  		c: c,
    31  	}
    32  	a := logsender.NewAPI(conn)
    33  	w, err := a.LogWriter()
    34  	c.Assert(err, gc.IsNil)
    35  
    36  	msg := new(params.LogRecord)
    37  	err = w.WriteLog(msg)
    38  	c.Assert(err, gc.IsNil)
    39  
    40  	c.Assert(conn.written, gc.HasLen, 1)
    41  	c.Assert(conn.written[0], gc.Equals, msg)
    42  
    43  	err = w.Close()
    44  	c.Assert(err, gc.IsNil)
    45  	c.Assert(conn.closeCount, gc.Equals, 1)
    46  }
    47  
    48  func (s *LogSenderSuite) TestNewAPIWriteLogError(c *gc.C) {
    49  	conn := &mockConnector{
    50  		c:            c,
    51  		connectError: errors.New("foo"),
    52  	}
    53  	a := logsender.NewAPI(conn)
    54  	w, err := a.LogWriter()
    55  	c.Assert(err, gc.ErrorMatches, "cannot connect to /logsink: foo")
    56  	c.Assert(w, gc.Equals, nil)
    57  }
    58  
    59  func (s *LogSenderSuite) TestNewAPIWriteError(c *gc.C) {
    60  	conn := &mockConnector{
    61  		c:          c,
    62  		writeError: errors.New("foo"),
    63  	}
    64  	a := logsender.NewAPI(conn)
    65  	w, err := a.LogWriter()
    66  	c.Assert(err, gc.IsNil)
    67  
    68  	err = w.WriteLog(new(params.LogRecord))
    69  	c.Assert(err, gc.ErrorMatches, "cannot send log message: foo")
    70  	c.Assert(conn.written, gc.HasLen, 0)
    71  }
    72  
    73  type mockConnector struct {
    74  	c *gc.C
    75  
    76  	connectError error
    77  	writeError   error
    78  	written      []interface{}
    79  
    80  	closeCount int
    81  }
    82  
    83  func (c *mockConnector) ConnectStream(path string, values url.Values) (base.Stream, error) {
    84  	c.c.Assert(path, gc.Equals, "/logsink")
    85  	c.c.Assert(values, jc.DeepEquals, url.Values{
    86  		"jujuclientversion": []string{version.Current.String()},
    87  		"version":           []string{"1"},
    88  	})
    89  	if c.connectError != nil {
    90  		return nil, c.connectError
    91  	}
    92  	return mockStream{c}, nil
    93  }
    94  
    95  type mockStream struct {
    96  	conn *mockConnector
    97  }
    98  
    99  func (s mockStream) WriteJSON(v interface{}) error {
   100  	if s.conn.writeError != nil {
   101  		return s.conn.writeError
   102  	}
   103  	s.conn.written = append(s.conn.written, v)
   104  	return nil
   105  }
   106  
   107  func (s mockStream) ReadJSON(v interface{}) error {
   108  	s.conn.c.Errorf("ReadJSON called unexpectedly")
   109  	return nil
   110  }
   111  
   112  func (s mockStream) NextReader() (messageType int, r io.Reader, err error) {
   113  	// NextReader is now called by the read loop thread.
   114  	// So just wait a bit and return so it doesn't sit in a very tight loop.
   115  	time.Sleep(time.Millisecond)
   116  	return 0, nil, nil
   117  }
   118  
   119  func (s mockStream) Close() error {
   120  	s.conn.closeCount++
   121  	return nil
   122  }