github.com/mattyw/juju@v0.0.0-20140610034352-732aecd63861/state/api/agent/machine_test.go (about)

     1  // Copyright 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package agent_test
     5  
     6  import (
     7  	"fmt"
     8  	stdtesting "testing"
     9  
    10  	"github.com/juju/errors"
    11  	jc "github.com/juju/testing/checkers"
    12  	"labix.org/v2/mgo"
    13  	gc "launchpad.net/gocheck"
    14  
    15  	"github.com/juju/juju/agent/mongo"
    16  	"github.com/juju/juju/environs"
    17  	"github.com/juju/juju/juju/testing"
    18  	"github.com/juju/juju/state"
    19  	"github.com/juju/juju/state/api"
    20  	"github.com/juju/juju/state/api/params"
    21  	apiserveragent "github.com/juju/juju/state/apiserver/agent"
    22  	coretesting "github.com/juju/juju/testing"
    23  )
    24  
    25  func TestAll(t *stdtesting.T) {
    26  	coretesting.MgoTestPackage(t)
    27  }
    28  
    29  type servingInfoSuite struct {
    30  	testing.JujuConnSuite
    31  }
    32  
    33  var _ = gc.Suite(&servingInfoSuite{})
    34  
    35  func (s *servingInfoSuite) TestStateServingInfo(c *gc.C) {
    36  	st, _ := s.OpenAPIAsNewMachine(c, state.JobManageEnviron)
    37  
    38  	expected := params.StateServingInfo{
    39  		PrivateKey:   "some key",
    40  		Cert:         "Some cert",
    41  		SharedSecret: "really, really secret",
    42  		APIPort:      33,
    43  		StatePort:    44,
    44  	}
    45  	s.State.SetStateServingInfo(expected)
    46  	info, err := st.Agent().StateServingInfo()
    47  	c.Assert(err, gc.IsNil)
    48  	c.Assert(info, jc.DeepEquals, expected)
    49  }
    50  
    51  func (s *servingInfoSuite) TestStateServingInfoPermission(c *gc.C) {
    52  	st, _ := s.OpenAPIAsNewMachine(c)
    53  
    54  	_, err := st.Agent().StateServingInfo()
    55  	c.Assert(err, gc.ErrorMatches, "permission denied")
    56  }
    57  
    58  func (s *servingInfoSuite) TestIsMaster(c *gc.C) {
    59  	calledIsMaster := false
    60  	var fakeMongoIsMaster = func(session *mgo.Session, m mongo.WithAddresses) (bool, error) {
    61  		calledIsMaster = true
    62  		return true, nil
    63  	}
    64  	s.PatchValue(&apiserveragent.MongoIsMaster, fakeMongoIsMaster)
    65  
    66  	st, _ := s.OpenAPIAsNewMachine(c, state.JobManageEnviron)
    67  	expected := true
    68  	result, err := st.Agent().IsMaster()
    69  
    70  	c.Assert(err, gc.IsNil)
    71  	c.Assert(result, gc.Equals, expected)
    72  	c.Assert(calledIsMaster, gc.Equals, true)
    73  }
    74  
    75  func (s *servingInfoSuite) TestIsMasterPermission(c *gc.C) {
    76  	st, _ := s.OpenAPIAsNewMachine(c)
    77  	_, err := st.Agent().IsMaster()
    78  	c.Assert(err, gc.ErrorMatches, "permission denied")
    79  }
    80  
    81  type machineSuite struct {
    82  	testing.JujuConnSuite
    83  	machine *state.Machine
    84  	st      *api.State
    85  }
    86  
    87  var _ = gc.Suite(&machineSuite{})
    88  
    89  func (s *machineSuite) SetUpTest(c *gc.C) {
    90  	s.JujuConnSuite.SetUpTest(c)
    91  	s.st, s.machine = s.OpenAPIAsNewMachine(c)
    92  }
    93  
    94  func (s *machineSuite) TestMachineEntity(c *gc.C) {
    95  	m, err := s.st.Agent().Entity("42")
    96  	c.Assert(err, gc.ErrorMatches, "permission denied")
    97  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
    98  	c.Assert(m, gc.IsNil)
    99  
   100  	m, err = s.st.Agent().Entity(s.machine.Tag())
   101  	c.Assert(err, gc.IsNil)
   102  	c.Assert(m.Tag(), gc.Equals, s.machine.Tag())
   103  	c.Assert(m.Life(), gc.Equals, params.Alive)
   104  	c.Assert(m.Jobs(), gc.DeepEquals, []params.MachineJob{params.JobHostUnits})
   105  
   106  	err = s.machine.EnsureDead()
   107  	c.Assert(err, gc.IsNil)
   108  	err = s.machine.Remove()
   109  	c.Assert(err, gc.IsNil)
   110  
   111  	m, err = s.st.Agent().Entity(s.machine.Tag())
   112  	c.Assert(err, gc.ErrorMatches, fmt.Sprintf("machine %s not found", s.machine.Id()))
   113  	c.Assert(err, jc.Satisfies, params.IsCodeNotFound)
   114  	c.Assert(m, gc.IsNil)
   115  }
   116  
   117  func (s *machineSuite) TestEntitySetPassword(c *gc.C) {
   118  	entity, err := s.st.Agent().Entity(s.machine.Tag())
   119  	c.Assert(err, gc.IsNil)
   120  
   121  	err = entity.SetPassword("foo")
   122  	c.Assert(err, gc.ErrorMatches, "password is only 3 bytes long, and is not a valid Agent password")
   123  	err = entity.SetPassword("foo-12345678901234567890")
   124  	c.Assert(err, gc.IsNil)
   125  
   126  	err = s.machine.Refresh()
   127  	c.Assert(err, gc.IsNil)
   128  	c.Assert(s.machine.PasswordValid("bar"), gc.Equals, false)
   129  	c.Assert(s.machine.PasswordValid("foo-12345678901234567890"), gc.Equals, true)
   130  
   131  	// Check that we cannot log in to mongo with the correct password.
   132  	// This is because there's no mongo password set for s.machine,
   133  	// which has JobHostUnits
   134  	info := s.StateInfo(c)
   135  	info.Tag = entity.Tag()
   136  	info.Password = "foo-12345678901234567890"
   137  	err = tryOpenState(info)
   138  	c.Assert(err, jc.Satisfies, errors.IsUnauthorized)
   139  }
   140  
   141  func tryOpenState(info *state.Info) error {
   142  	st, err := state.Open(info, state.DialOpts{}, environs.NewStatePolicy())
   143  	if err == nil {
   144  		st.Close()
   145  	}
   146  	return err
   147  }