launchpad.net/~rogpeppe/juju-core/500-errgo-fix@v0.0.0-20140213181702-000000002356/provider/maas/instance_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package maas
     5  
     6  import (
     7  	"fmt"
     8  
     9  	gc "launchpad.net/gocheck"
    10  
    11  	"launchpad.net/juju-core/instance"
    12  )
    13  
    14  type instanceTest struct {
    15  	providerSuite
    16  }
    17  
    18  var _ = gc.Suite(&instanceTest{})
    19  
    20  func (s *instanceTest) TestId(c *gc.C) {
    21  	jsonValue := `{"system_id": "system_id", "test": "test"}`
    22  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
    23  	resourceURI, _ := obj.GetField("resource_uri")
    24  	instance := maasInstance{maasObject: &obj, environ: s.makeEnviron()}
    25  
    26  	c.Check(string(instance.Id()), gc.Equals, resourceURI)
    27  }
    28  
    29  func (s *instanceTest) TestString(c *gc.C) {
    30  	jsonValue := `{"hostname": "thethingintheplace", "system_id": "system_id", "test": "test"}`
    31  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
    32  	instance := &maasInstance{maasObject: &obj, environ: s.makeEnviron()}
    33  	hostname, err := instance.DNSName()
    34  	c.Assert(err, gc.IsNil)
    35  	expected := hostname + ":" + string(instance.Id())
    36  	c.Assert(fmt.Sprint(instance), gc.Equals, expected)
    37  }
    38  
    39  func (s *instanceTest) TestStringWithoutHostname(c *gc.C) {
    40  	// For good measure, test what happens if we don't have a hostname.
    41  	jsonValue := `{"system_id": "system_id", "test": "test"}`
    42  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
    43  	instance := &maasInstance{maasObject: &obj, environ: s.makeEnviron()}
    44  	_, err := instance.DNSName()
    45  	c.Assert(err, gc.NotNil)
    46  	expected := fmt.Sprintf("<DNSName failed: %q>", err) + ":" + string(instance.Id())
    47  	c.Assert(fmt.Sprint(instance), gc.Equals, expected)
    48  }
    49  
    50  func (s *instanceTest) TestRefreshInstance(c *gc.C) {
    51  	jsonValue := `{"system_id": "system_id", "test": "test"}`
    52  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
    53  	s.testMAASObject.TestServer.ChangeNode("system_id", "test2", "test2")
    54  	instance := maasInstance{maasObject: &obj, environ: s.makeEnviron()}
    55  
    56  	err := instance.Refresh()
    57  
    58  	c.Check(err, gc.IsNil)
    59  	testField, err := (*instance.maasObject).GetField("test2")
    60  	c.Check(err, gc.IsNil)
    61  	c.Check(testField, gc.Equals, "test2")
    62  }
    63  
    64  func (s *instanceTest) TestDNSName(c *gc.C) {
    65  	jsonValue := `{"hostname": "DNS name", "system_id": "system_id"}`
    66  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
    67  	instance := maasInstance{maasObject: &obj, environ: s.makeEnviron()}
    68  
    69  	dnsName, err := instance.DNSName()
    70  
    71  	c.Check(err, gc.IsNil)
    72  	c.Check(dnsName, gc.Equals, "DNS name")
    73  
    74  	// WaitDNSName() currently simply calls DNSName().
    75  	dnsName, err = instance.WaitDNSName()
    76  
    77  	c.Check(err, gc.IsNil)
    78  	c.Check(dnsName, gc.Equals, "DNS name")
    79  }
    80  
    81  func (s *instanceTest) TestAddresses(c *gc.C) {
    82  	jsonValue := `{
    83  			"hostname": "testing.invalid",
    84  			"system_id": "system_id",
    85  			"ip_addresses": [ "1.2.3.4", "fe80::d806:dbff:fe23:1199" ]
    86  		}`
    87  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
    88  	inst := maasInstance{maasObject: &obj, environ: s.makeEnviron()}
    89  
    90  	expected := []instance.Address{
    91  		{Value: "testing.invalid", Type: instance.HostName, NetworkScope: instance.NetworkPublic},
    92  		instance.NewAddress("1.2.3.4"),
    93  		instance.NewAddress("fe80::d806:dbff:fe23:1199"),
    94  	}
    95  
    96  	addr, err := inst.Addresses()
    97  
    98  	c.Assert(err, gc.IsNil)
    99  	c.Check(addr, gc.DeepEquals, expected)
   100  }
   101  
   102  func (s *instanceTest) TestAddressesMissing(c *gc.C) {
   103  	// Older MAAS versions do not have ip_addresses returned, for these
   104  	// just the DNS name should be returned without error.
   105  	jsonValue := `{
   106  		"hostname": "testing.invalid",
   107  		"system_id": "system_id"
   108  		}`
   109  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
   110  	inst := maasInstance{maasObject: &obj, environ: s.makeEnviron()}
   111  
   112  	addr, err := inst.Addresses()
   113  	c.Assert(err, gc.IsNil)
   114  	c.Check(addr, gc.DeepEquals, []instance.Address{
   115  		{Value: "testing.invalid", Type: instance.HostName, NetworkScope: instance.NetworkPublic},
   116  	})
   117  }
   118  
   119  func (s *instanceTest) TestAddressesInvalid(c *gc.C) {
   120  	jsonValue := `{
   121  		"hostname": "testing.invalid",
   122  		"system_id": "system_id",
   123  		"ip_addresses": "incompatible"
   124  		}`
   125  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
   126  	inst := maasInstance{maasObject: &obj, environ: s.makeEnviron()}
   127  
   128  	_, err := inst.Addresses()
   129  	c.Assert(err, gc.NotNil)
   130  }
   131  
   132  func (s *instanceTest) TestAddressesInvalidContents(c *gc.C) {
   133  	jsonValue := `{
   134  		"hostname": "testing.invalid",
   135  		"system_id": "system_id",
   136  		"ip_addresses": [42]
   137  		}`
   138  	obj := s.testMAASObject.TestServer.NewNode(jsonValue)
   139  	inst := maasInstance{maasObject: &obj, environ: s.makeEnviron()}
   140  
   141  	_, err := inst.Addresses()
   142  	c.Assert(err, gc.NotNil)
   143  }