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