github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/worker/meterstatus/state_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package meterstatus_test
     5  
     6  import (
     7  	"path"
     8  	"time"
     9  
    10  	"github.com/juju/errors"
    11  	jc "github.com/juju/testing/checkers"
    12  	"go.uber.org/mock/gomock"
    13  	gc "gopkg.in/check.v1"
    14  	"gopkg.in/yaml.v2"
    15  
    16  	"github.com/juju/juju/rpc/params"
    17  	"github.com/juju/juju/worker/meterstatus"
    18  	"github.com/juju/juju/worker/meterstatus/mocks"
    19  )
    20  
    21  type DiskBackedStateSuite struct {
    22  	path  string
    23  	state *meterstatus.DiskBackedState
    24  }
    25  
    26  var _ = gc.Suite(&DiskBackedStateSuite{})
    27  
    28  func (t *DiskBackedStateSuite) SetUpTest(c *gc.C) {
    29  	t.path = path.Join(c.MkDir(), "state.yaml")
    30  	t.state = meterstatus.NewDiskBackedState(t.path)
    31  }
    32  
    33  func (t *DiskBackedStateSuite) TestReadNonExist(c *gc.C) {
    34  	_, err := t.state.Read()
    35  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
    36  }
    37  
    38  func (t *DiskBackedStateSuite) TestWriteRead(c *gc.C) {
    39  	initial := &meterstatus.State{
    40  		Code: "GREEN",
    41  		Info: "some message",
    42  	}
    43  	err := t.state.Write(initial)
    44  	c.Assert(err, jc.ErrorIsNil)
    45  
    46  	st, err := t.state.Read()
    47  	c.Assert(err, jc.ErrorIsNil)
    48  	c.Assert(st.Code, gc.Equals, initial.Code)
    49  	c.Assert(st.Info, gc.Equals, initial.Info)
    50  }
    51  
    52  func (t *DiskBackedStateSuite) TestWriteReadExtra(c *gc.C) {
    53  	initial := &meterstatus.State{
    54  		Code: "GREEN",
    55  		Info: "some message",
    56  	}
    57  	err := t.state.Write(initial)
    58  	c.Assert(err, jc.ErrorIsNil)
    59  
    60  	st, err := t.state.Read()
    61  	c.Assert(err, jc.ErrorIsNil)
    62  	c.Assert(st.Code, gc.Equals, initial.Code)
    63  	c.Assert(st.Info, gc.Equals, initial.Info)
    64  	c.Assert(st.Disconnected, gc.IsNil)
    65  
    66  	st.Disconnected = &meterstatus.Disconnected{
    67  		Disconnected: time.Now().Unix(),
    68  		State:        meterstatus.WaitingRed,
    69  	}
    70  
    71  	err = t.state.Write(st)
    72  	c.Assert(err, jc.ErrorIsNil)
    73  
    74  	newSt, err := t.state.Read()
    75  	c.Assert(err, jc.ErrorIsNil)
    76  	c.Assert(newSt.Code, gc.Equals, st.Code)
    77  	c.Assert(newSt.Info, gc.Equals, st.Info)
    78  	c.Assert(newSt.Disconnected, gc.DeepEquals, st.Disconnected)
    79  }
    80  
    81  type ControllerBackedStateSuite struct {
    82  }
    83  
    84  var _ = gc.Suite(&ControllerBackedStateSuite{})
    85  
    86  func (t *ControllerBackedStateSuite) TestReadNonExist(c *gc.C) {
    87  	ctrl := gomock.NewController(c)
    88  	defer ctrl.Finish()
    89  
    90  	api := mocks.NewMockUnitStateAPI(ctrl)
    91  	api.EXPECT().State().Return(params.UnitStateResult{}, nil)
    92  
    93  	stateReader := meterstatus.NewControllerBackedState(api)
    94  	_, err := stateReader.Read()
    95  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
    96  }
    97  
    98  func (t *ControllerBackedStateSuite) TestRead(c *gc.C) {
    99  	ctrl := gomock.NewController(c)
   100  	defer ctrl.Finish()
   101  
   102  	exp := &meterstatus.State{
   103  		Code: "code",
   104  		Info: "info",
   105  		Disconnected: &meterstatus.Disconnected{
   106  			Disconnected: 123,
   107  			State:        meterstatus.WaitingRed,
   108  		},
   109  	}
   110  
   111  	data, err := yaml.Marshal(exp)
   112  	c.Assert(err, jc.ErrorIsNil)
   113  
   114  	api := mocks.NewMockUnitStateAPI(ctrl)
   115  	api.EXPECT().State().Return(params.UnitStateResult{MeterStatusState: string(data)}, nil)
   116  
   117  	stateReader := meterstatus.NewControllerBackedState(api)
   118  	got, err := stateReader.Read()
   119  	c.Assert(err, jc.ErrorIsNil)
   120  	c.Assert(got, jc.DeepEquals, exp)
   121  }
   122  
   123  func (t *ControllerBackedStateSuite) TestWrite(c *gc.C) {
   124  	ctrl := gomock.NewController(c)
   125  	defer ctrl.Finish()
   126  
   127  	st := &meterstatus.State{
   128  		Code: "code",
   129  		Info: "info",
   130  		Disconnected: &meterstatus.Disconnected{
   131  			Disconnected: 123,
   132  		},
   133  	}
   134  
   135  	api := mocks.NewMockUnitStateAPI(ctrl)
   136  	api.EXPECT().SetState(expUnitStateArg(c, st)).Return(nil)
   137  
   138  	stateReadWriter := meterstatus.NewControllerBackedState(api)
   139  	err := stateReadWriter.Write(st)
   140  	c.Assert(err, jc.ErrorIsNil)
   141  }
   142  
   143  func expUnitStateArg(c *gc.C, st *meterstatus.State) params.SetUnitStateArg {
   144  	data, err := yaml.Marshal(st)
   145  	c.Assert(err, jc.ErrorIsNil)
   146  
   147  	dataStr := string(data)
   148  	return params.SetUnitStateArg{
   149  		MeterStatusState: &dataStr,
   150  	}
   151  }