github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/state/ipaddresses_internal_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package state
     5  
     6  import (
     7  	"github.com/juju/testing"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  
    11  	"github.com/juju/juju/network"
    12  	coretesting "github.com/juju/juju/testing"
    13  )
    14  
    15  // ipAddressesInternalSuite contains black-box tests for IP addresses'
    16  // internals, which do not actually access mongo. The rest of the logic is
    17  // tested in ipAddressesStateSuite.
    18  type ipAddressesInternalSuite struct {
    19  	testing.IsolationSuite
    20  }
    21  
    22  var _ = gc.Suite(&ipAddressesInternalSuite{})
    23  
    24  func (s *ipAddressesInternalSuite) TestNewIPAddressCreatesAddress(c *gc.C) {
    25  	result := newIPAddress(nil, ipAddressDoc{})
    26  	c.Assert(result, gc.NotNil)
    27  	c.Assert(result.st, gc.IsNil)
    28  	c.Assert(result.doc, jc.DeepEquals, ipAddressDoc{})
    29  }
    30  
    31  func (s *ipAddressesInternalSuite) TestDocIDIncludesModelUUID(c *gc.C) {
    32  	const localDocID = "foo"
    33  	globalDocID := coretesting.ModelTag.Id() + ":" + localDocID
    34  
    35  	result := s.newIPAddressWithDummyState(ipAddressDoc{DocID: localDocID})
    36  	c.Assert(result.DocID(), gc.Equals, globalDocID)
    37  
    38  	result = s.newIPAddressWithDummyState(ipAddressDoc{DocID: globalDocID})
    39  	c.Assert(result.DocID(), gc.Equals, globalDocID)
    40  }
    41  
    42  func (s *ipAddressesInternalSuite) newIPAddressWithDummyState(doc ipAddressDoc) *Address {
    43  	// We only need the model UUID set for localID() and docID() to work.
    44  	// The rest is tested in ipAddressesStateSuite.
    45  	dummyState := &State{modelTag: coretesting.ModelTag}
    46  	return newIPAddress(dummyState, doc)
    47  }
    48  
    49  func (s *ipAddressesInternalSuite) TestProviderIDIsEmptyWhenNotSet(c *gc.C) {
    50  	result := s.newIPAddressWithDummyState(ipAddressDoc{})
    51  	c.Assert(result.ProviderID(), gc.Equals, network.Id(""))
    52  }
    53  
    54  func (s *ipAddressesInternalSuite) TestProviderIDDoesNotIncludeModelUUIDWhenSet(c *gc.C) {
    55  	const localProviderID = "foo"
    56  	globalProviderID := coretesting.ModelTag.Id() + ":" + localProviderID
    57  
    58  	result := s.newIPAddressWithDummyState(ipAddressDoc{ProviderID: localProviderID})
    59  	c.Assert(result.ProviderID(), gc.Equals, network.Id(localProviderID))
    60  	c.Assert(result.localProviderID(), gc.Equals, localProviderID)
    61  
    62  	result = s.newIPAddressWithDummyState(ipAddressDoc{ProviderID: globalProviderID})
    63  	c.Assert(result.ProviderID(), gc.Equals, network.Id(localProviderID))
    64  	c.Assert(result.localProviderID(), gc.Equals, localProviderID)
    65  }
    66  
    67  func (s *ipAddressesInternalSuite) TestIPAddressGlobalKeyHelper(c *gc.C) {
    68  	result := ipAddressGlobalKey("42", "eth0", "0.1.2.3")
    69  	c.Assert(result, gc.Equals, "m#42#d#eth0#ip#0.1.2.3")
    70  
    71  	result = ipAddressGlobalKey("", "ignored", "anything")
    72  	c.Assert(result, gc.Equals, "")
    73  
    74  	result = ipAddressGlobalKey("ignored", "", "anything")
    75  	c.Assert(result, gc.Equals, "")
    76  
    77  	result = ipAddressGlobalKey("", "", "anything")
    78  	c.Assert(result, gc.Equals, "")
    79  
    80  	result = ipAddressGlobalKey("", "", "")
    81  	c.Assert(result, gc.Equals, "")
    82  }
    83  
    84  func (s *ipAddressesInternalSuite) TestGlobalKeyMethod(c *gc.C) {
    85  	doc := ipAddressDoc{
    86  		MachineID:  "99",
    87  		DeviceName: "br-eth1.250",
    88  		Value:      "fc00:1234::/64",
    89  	}
    90  	address := s.newIPAddressWithDummyState(doc)
    91  	c.Check(address.globalKey(), gc.Equals, "m#99#d#br-eth1.250#ip#fc00:1234::/64")
    92  
    93  	address = s.newIPAddressWithDummyState(ipAddressDoc{})
    94  	c.Check(address.globalKey(), gc.Equals, "")
    95  }
    96  
    97  func (s *ipAddressesInternalSuite) TestStringIncludesConfigMethodAndValue(c *gc.C) {
    98  	doc := ipAddressDoc{
    99  		ConfigMethod: ManualAddress,
   100  		Value:        "0.1.2.3",
   101  		MachineID:    "42",
   102  		DeviceName:   "eno1",
   103  	}
   104  	result := s.newIPAddressWithDummyState(doc)
   105  	expectedString := `manual address "0.1.2.3" of device "eno1" on machine "42"`
   106  
   107  	c.Assert(result.String(), gc.Equals, expectedString)
   108  
   109  	result = s.newIPAddressWithDummyState(ipAddressDoc{})
   110  	c.Assert(result.String(), gc.Equals, ` address "" of device "" on machine ""`)
   111  }
   112  
   113  func (s *ipAddressesInternalSuite) TestRemainingSimpleGetterMethods(c *gc.C) {
   114  	doc := ipAddressDoc{
   115  		DeviceName:       "eth0",
   116  		MachineID:        "42",
   117  		SubnetCIDR:       "10.20.30.0/24",
   118  		ConfigMethod:     StaticAddress,
   119  		Value:            "10.20.30.40",
   120  		DNSServers:       []string{"ns1.example.com", "ns2.example.org"},
   121  		DNSSearchDomains: []string{"example.com", "example.org"},
   122  		GatewayAddress:   "10.20.30.1",
   123  	}
   124  	result := s.newIPAddressWithDummyState(doc)
   125  
   126  	c.Check(result.DeviceName(), gc.Equals, "eth0")
   127  	c.Check(result.MachineID(), gc.Equals, "42")
   128  	c.Check(result.SubnetCIDR(), gc.Equals, "10.20.30.0/24")
   129  	c.Check(result.ConfigMethod(), gc.Equals, StaticAddress)
   130  	c.Check(result.Value(), gc.Equals, "10.20.30.40")
   131  	c.Check(result.DNSServers(), jc.DeepEquals, []string{"ns1.example.com", "ns2.example.org"})
   132  	c.Check(result.DNSSearchDomains(), jc.DeepEquals, []string{"example.com", "example.org"})
   133  	c.Check(result.GatewayAddress(), gc.Equals, "10.20.30.1")
   134  }
   135  
   136  func (s *ipAddressesInternalSuite) TestIsValidAddressConfigMethodWithValidValues(c *gc.C) {
   137  	validTypes := []AddressConfigMethod{
   138  		LoopbackAddress,
   139  		StaticAddress,
   140  		DynamicAddress,
   141  		ManualAddress,
   142  	}
   143  
   144  	for _, value := range validTypes {
   145  		result := IsValidAddressConfigMethod(string(value))
   146  		c.Check(result, jc.IsTrue)
   147  	}
   148  }
   149  
   150  func (s *ipAddressesInternalSuite) TestIsValidAddressConfigMethodWithInvalidValues(c *gc.C) {
   151  	result := IsValidAddressConfigMethod("")
   152  	c.Check(result, jc.IsFalse)
   153  
   154  	result = IsValidAddressConfigMethod("anything")
   155  	c.Check(result, jc.IsFalse)
   156  
   157  	result = IsValidAddressConfigMethod(" ")
   158  	c.Check(result, jc.IsFalse)
   159  }