github.com/wallyworld/juju@v0.0.0-20161013125918-6cf1bc9d917a/api/logfwd/lastsent_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package logfwd_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  	"gopkg.in/juju/names.v2"
    12  
    13  	"github.com/juju/juju/api/logfwd"
    14  	"github.com/juju/juju/apiserver/common"
    15  	"github.com/juju/juju/apiserver/params"
    16  	"github.com/juju/juju/state"
    17  	"time"
    18  )
    19  
    20  type LastSentSuite struct {
    21  	testing.IsolationSuite
    22  }
    23  
    24  var _ = gc.Suite(&LastSentSuite{})
    25  
    26  func (s *LastSentSuite) TestGetLastSent(c *gc.C) {
    27  	stub := &testing.Stub{}
    28  	caller := &stubFacadeCaller{stub: stub}
    29  	caller.ReturnFacadeCallGet = params.LogForwardingGetLastSentResults{
    30  		Results: []params.LogForwardingGetLastSentResult{{
    31  			RecordID:        10,
    32  			RecordTimestamp: 100,
    33  		}, {
    34  			RecordID:        20,
    35  			RecordTimestamp: 200,
    36  		}, {
    37  			Error: common.ServerError(errors.NewNotFound(state.ErrNeverForwarded, "")),
    38  		}},
    39  	}
    40  	client := logfwd.NewLastSentClient(caller.newFacadeCaller)
    41  	model := "deadbeef-2f18-4fd2-967d-db9663db7bea"
    42  	modelTag := names.NewModelTag(model)
    43  
    44  	results, err := client.GetLastSent([]logfwd.LastSentID{{
    45  		Model: modelTag,
    46  		Sink:  "spam",
    47  	}, {
    48  		Model: modelTag,
    49  		Sink:  "eggs",
    50  	}, {
    51  		Model: modelTag,
    52  		Sink:  "ham",
    53  	}})
    54  	c.Assert(err, jc.ErrorIsNil)
    55  
    56  	c.Check(results, jc.DeepEquals, []logfwd.LastSentResult{{
    57  		LastSentInfo: logfwd.LastSentInfo{
    58  			LastSentID: logfwd.LastSentID{
    59  				Model: modelTag,
    60  				Sink:  "spam",
    61  			},
    62  			RecordID:        10,
    63  			RecordTimestamp: time.Unix(0, 100),
    64  		},
    65  	}, {
    66  		LastSentInfo: logfwd.LastSentInfo{
    67  			LastSentID: logfwd.LastSentID{
    68  				Model: modelTag,
    69  				Sink:  "eggs",
    70  			},
    71  			RecordID:        20,
    72  			RecordTimestamp: time.Unix(0, 200),
    73  		},
    74  	}, {
    75  		LastSentInfo: logfwd.LastSentInfo{
    76  			LastSentID: logfwd.LastSentID{
    77  				Model: modelTag,
    78  				Sink:  "ham",
    79  			},
    80  		},
    81  		Error: common.RestoreError(&params.Error{
    82  			Message: `cannot find ID of the last forwarded record`,
    83  			Code:    params.CodeNotFound,
    84  		}),
    85  	}})
    86  	stub.CheckCallNames(c, "newFacadeCaller", "FacadeCall")
    87  	stub.CheckCall(c, 0, "newFacadeCaller", "LogForwarding")
    88  	stub.CheckCall(c, 1, "FacadeCall", "GetLastSent", params.LogForwardingGetLastSentParams{
    89  		IDs: []params.LogForwardingID{{
    90  			ModelTag: modelTag.String(),
    91  			Sink:     "spam",
    92  		}, {
    93  			ModelTag: modelTag.String(),
    94  			Sink:     "eggs",
    95  		}, {
    96  			ModelTag: modelTag.String(),
    97  			Sink:     "ham",
    98  		}},
    99  	})
   100  }
   101  
   102  func (s *LastSentSuite) TestSetLastSent(c *gc.C) {
   103  	stub := &testing.Stub{}
   104  	caller := &stubFacadeCaller{stub: stub}
   105  	apiError := common.ServerError(errors.New("<failed>"))
   106  	caller.ReturnFacadeCallSet = params.ErrorResults{
   107  		Results: []params.ErrorResult{{
   108  			Error: nil,
   109  		}, {
   110  			Error: nil,
   111  		}, {
   112  			Error: apiError,
   113  		}},
   114  	}
   115  	client := logfwd.NewLastSentClient(caller.newFacadeCaller)
   116  	model := "deadbeef-2f18-4fd2-967d-db9663db7bea"
   117  	modelTag := names.NewModelTag(model)
   118  
   119  	results, err := client.SetLastSent([]logfwd.LastSentInfo{{
   120  		LastSentID: logfwd.LastSentID{
   121  			Model: modelTag,
   122  			Sink:  "spam",
   123  		},
   124  		RecordID:        10,
   125  		RecordTimestamp: time.Unix(0, 100),
   126  	}, {
   127  		LastSentID: logfwd.LastSentID{
   128  			Model: modelTag,
   129  			Sink:  "eggs",
   130  		},
   131  		RecordID:        20,
   132  		RecordTimestamp: time.Unix(0, 200),
   133  	}, {
   134  		LastSentID: logfwd.LastSentID{
   135  			Model: modelTag,
   136  			Sink:  "ham",
   137  		},
   138  		RecordID:        15,
   139  		RecordTimestamp: time.Unix(0, 150),
   140  	}})
   141  	c.Assert(err, jc.ErrorIsNil)
   142  
   143  	c.Check(results, jc.DeepEquals, []logfwd.LastSentResult{{
   144  		LastSentInfo: logfwd.LastSentInfo{
   145  			LastSentID: logfwd.LastSentID{
   146  				Model: modelTag,
   147  				Sink:  "spam",
   148  			},
   149  			RecordID:        10,
   150  			RecordTimestamp: time.Unix(0, 100),
   151  		},
   152  	}, {
   153  		LastSentInfo: logfwd.LastSentInfo{
   154  			LastSentID: logfwd.LastSentID{
   155  				Model: modelTag,
   156  				Sink:  "eggs",
   157  			},
   158  			RecordID:        20,
   159  			RecordTimestamp: time.Unix(0, 200),
   160  		},
   161  	}, {
   162  		LastSentInfo: logfwd.LastSentInfo{
   163  			LastSentID: logfwd.LastSentID{
   164  				Model: modelTag,
   165  				Sink:  "ham",
   166  			},
   167  			RecordID:        15,
   168  			RecordTimestamp: time.Unix(0, 150),
   169  		},
   170  		Error: common.RestoreError(apiError),
   171  	}})
   172  	stub.CheckCallNames(c, "newFacadeCaller", "FacadeCall")
   173  	stub.CheckCall(c, 0, "newFacadeCaller", "LogForwarding")
   174  	stub.CheckCall(c, 1, "FacadeCall", "SetLastSent", params.LogForwardingSetLastSentParams{
   175  		Params: []params.LogForwardingSetLastSentParam{{
   176  			LogForwardingID: params.LogForwardingID{
   177  				ModelTag: modelTag.String(),
   178  				Sink:     "spam",
   179  			},
   180  			RecordID:        10,
   181  			RecordTimestamp: 100,
   182  		}, {
   183  			LogForwardingID: params.LogForwardingID{
   184  				ModelTag: modelTag.String(),
   185  				Sink:     "eggs",
   186  			},
   187  			RecordID:        20,
   188  			RecordTimestamp: 200,
   189  		}, {
   190  			LogForwardingID: params.LogForwardingID{
   191  				ModelTag: modelTag.String(),
   192  				Sink:     "ham",
   193  			},
   194  			RecordID:        15,
   195  			RecordTimestamp: 150,
   196  		}},
   197  	})
   198  }
   199  
   200  type stubFacadeCaller struct {
   201  	stub *testing.Stub
   202  
   203  	ReturnFacadeCallGet params.LogForwardingGetLastSentResults
   204  	ReturnFacadeCallSet params.ErrorResults
   205  }
   206  
   207  func (s *stubFacadeCaller) newFacadeCaller(facade string) logfwd.FacadeCaller {
   208  	s.stub.AddCall("newFacadeCaller", facade)
   209  	s.stub.NextErr()
   210  
   211  	return s
   212  }
   213  
   214  func (s *stubFacadeCaller) FacadeCall(request string, args, response interface{}) error {
   215  	s.stub.AddCall("FacadeCall", request, args)
   216  	if err := s.stub.NextErr(); err != nil {
   217  		return err
   218  	}
   219  
   220  	switch request {
   221  	case "GetLastSent":
   222  		actual := response.(*params.LogForwardingGetLastSentResults)
   223  		*actual = s.ReturnFacadeCallGet
   224  	case "SetLastSent":
   225  		actual := response.(*params.ErrorResults)
   226  		*actual = s.ReturnFacadeCallSet
   227  	}
   228  	return nil
   229  }