github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/worker/conv2state/converter_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package conv2state
     5  
     6  import (
     7  	stderrs "errors"
     8  	"testing"
     9  
    10  	"github.com/juju/errors"
    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/apiserver/params"
    16  	"github.com/juju/juju/state/multiwatcher"
    17  	coretesting "github.com/juju/juju/testing"
    18  )
    19  
    20  var _ = gc.Suite(&Suite{})
    21  
    22  func TestPackage(t *testing.T) {
    23  	gc.TestingT(t)
    24  }
    25  
    26  type Suite struct {
    27  	coretesting.BaseSuite
    28  }
    29  
    30  func (Suite) TestSetUp(c *gc.C) {
    31  	a := &fakeAgent{tag: names.NewMachineTag("1")}
    32  	m := &fakeMachine{}
    33  	mr := &fakeMachiner{m: m}
    34  	conv := converter{machiner: mr, agent: a}
    35  	w, err := conv.SetUp()
    36  	c.Assert(err, gc.IsNil)
    37  	c.Assert(conv.machine, gc.Equals, m)
    38  	c.Assert(mr.gotTag, gc.Equals, a.tag.(names.MachineTag))
    39  	c.Assert(w, gc.Equals, m.w)
    40  }
    41  
    42  func (Suite) TestSetupMachinerErr(c *gc.C) {
    43  	a := &fakeAgent{tag: names.NewMachineTag("1")}
    44  	mr := &fakeMachiner{err: stderrs.New("foo")}
    45  	conv := converter{machiner: mr, agent: a}
    46  	w, err := conv.SetUp()
    47  	c.Assert(errors.Cause(err), gc.Equals, mr.err)
    48  	c.Assert(mr.gotTag, gc.Equals, a.tag.(names.MachineTag))
    49  	c.Assert(w, gc.IsNil)
    50  }
    51  
    52  func (Suite) TestSetupWatchErr(c *gc.C) {
    53  	a := &fakeAgent{tag: names.NewMachineTag("1")}
    54  	m := &fakeMachine{watchErr: stderrs.New("foo")}
    55  	mr := &fakeMachiner{m: m}
    56  	conv := &converter{machiner: mr, agent: a}
    57  	w, err := conv.SetUp()
    58  	c.Assert(errors.Cause(err), gc.Equals, m.watchErr)
    59  	c.Assert(mr.gotTag, gc.Equals, a.tag.(names.MachineTag))
    60  	c.Assert(w, gc.IsNil)
    61  }
    62  
    63  func (s Suite) TestHandle(c *gc.C) {
    64  	a := &fakeAgent{tag: names.NewMachineTag("1")}
    65  	jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits, multiwatcher.JobManageModel}
    66  	m := &fakeMachine{
    67  		jobs: &params.JobsResult{Jobs: jobs},
    68  	}
    69  	mr := &fakeMachiner{m: m}
    70  	conv := &converter{machiner: mr, agent: a}
    71  	_, err := conv.SetUp()
    72  	c.Assert(err, gc.IsNil)
    73  	err = conv.Handle(nil)
    74  	c.Assert(err, gc.IsNil)
    75  	c.Assert(a.didRestart, jc.IsTrue)
    76  }
    77  
    78  func (s Suite) TestHandleNoManageEnviron(c *gc.C) {
    79  	a := &fakeAgent{tag: names.NewMachineTag("1")}
    80  	jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits}
    81  	m := &fakeMachine{
    82  		jobs: &params.JobsResult{Jobs: jobs},
    83  	}
    84  	mr := &fakeMachiner{m: m}
    85  	conv := &converter{machiner: mr, agent: a}
    86  	_, err := conv.SetUp()
    87  	c.Assert(err, gc.IsNil)
    88  	err = conv.Handle(nil)
    89  	c.Assert(err, gc.IsNil)
    90  	c.Assert(a.didRestart, jc.IsFalse)
    91  }
    92  
    93  func (Suite) TestHandleJobsError(c *gc.C) {
    94  	a := &fakeAgent{tag: names.NewMachineTag("1")}
    95  	jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits, multiwatcher.JobManageModel}
    96  	m := &fakeMachine{
    97  		jobs:    &params.JobsResult{Jobs: jobs},
    98  		jobsErr: errors.New("foo"),
    99  	}
   100  	mr := &fakeMachiner{m: m}
   101  	conv := &converter{machiner: mr, agent: a}
   102  	_, err := conv.SetUp()
   103  	c.Assert(err, gc.IsNil)
   104  	err = conv.Handle(nil)
   105  	c.Assert(errors.Cause(err), gc.Equals, m.jobsErr)
   106  	c.Assert(a.didRestart, jc.IsFalse)
   107  }
   108  
   109  func (s Suite) TestHandleRestartError(c *gc.C) {
   110  	a := &fakeAgent{
   111  		tag:        names.NewMachineTag("1"),
   112  		restartErr: errors.New("foo"),
   113  	}
   114  	jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits, multiwatcher.JobManageModel}
   115  	m := &fakeMachine{
   116  		jobs: &params.JobsResult{Jobs: jobs},
   117  	}
   118  	mr := &fakeMachiner{m: m}
   119  	conv := &converter{machiner: mr, agent: a}
   120  	_, err := conv.SetUp()
   121  	c.Assert(err, gc.IsNil)
   122  	err = conv.Handle(nil)
   123  	c.Assert(errors.Cause(err), gc.Equals, a.restartErr)
   124  
   125  	// We set this to true whenver the function is called, even though we're
   126  	// returning an error from it.
   127  	c.Assert(a.didRestart, jc.IsTrue)
   128  }