github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/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) TestProviderID(c *gc.C) {
    55  	result := s.newIPAddressWithDummyState(ipAddressDoc{ProviderID: "foo"})
    56  	c.Assert(result.ProviderID(), gc.Equals, network.Id("foo"))
    57  }
    58  
    59  func (s *ipAddressesInternalSuite) TestIPAddressGlobalKeyHelper(c *gc.C) {
    60  	result := ipAddressGlobalKey("42", "eth0", "0.1.2.3")
    61  	c.Assert(result, gc.Equals, "m#42#d#eth0#ip#0.1.2.3")
    62  
    63  	result = ipAddressGlobalKey("", "ignored", "anything")
    64  	c.Assert(result, gc.Equals, "")
    65  
    66  	result = ipAddressGlobalKey("ignored", "", "anything")
    67  	c.Assert(result, gc.Equals, "")
    68  
    69  	result = ipAddressGlobalKey("", "", "anything")
    70  	c.Assert(result, gc.Equals, "")
    71  
    72  	result = ipAddressGlobalKey("", "", "")
    73  	c.Assert(result, gc.Equals, "")
    74  }
    75  
    76  func (s *ipAddressesInternalSuite) TestGlobalKeyMethod(c *gc.C) {
    77  	doc := ipAddressDoc{
    78  		MachineID:  "99",
    79  		DeviceName: "br-eth1.250",
    80  		Value:      "fc00:1234::/64",
    81  	}
    82  	address := s.newIPAddressWithDummyState(doc)
    83  	c.Check(address.globalKey(), gc.Equals, "m#99#d#br-eth1.250#ip#fc00:1234::/64")
    84  
    85  	address = s.newIPAddressWithDummyState(ipAddressDoc{})
    86  	c.Check(address.globalKey(), gc.Equals, "")
    87  }
    88  
    89  func (s *ipAddressesInternalSuite) TestStringIncludesConfigMethodAndValue(c *gc.C) {
    90  	doc := ipAddressDoc{
    91  		ConfigMethod: ManualAddress,
    92  		Value:        "0.1.2.3",
    93  		MachineID:    "42",
    94  		DeviceName:   "eno1",
    95  	}
    96  	result := s.newIPAddressWithDummyState(doc)
    97  	expectedString := `manual address "0.1.2.3" of device "eno1" on machine "42"`
    98  
    99  	c.Assert(result.String(), gc.Equals, expectedString)
   100  
   101  	result = s.newIPAddressWithDummyState(ipAddressDoc{})
   102  	c.Assert(result.String(), gc.Equals, ` address "" of device "" on machine ""`)
   103  }
   104  
   105  func (s *ipAddressesInternalSuite) TestRemainingSimpleGetterMethods(c *gc.C) {
   106  	doc := ipAddressDoc{
   107  		DeviceName:       "eth0",
   108  		MachineID:        "42",
   109  		SubnetCIDR:       "10.20.30.0/24",
   110  		ConfigMethod:     StaticAddress,
   111  		Value:            "10.20.30.40",
   112  		DNSServers:       []string{"ns1.example.com", "ns2.example.org"},
   113  		DNSSearchDomains: []string{"example.com", "example.org"},
   114  		GatewayAddress:   "10.20.30.1",
   115  	}
   116  	result := s.newIPAddressWithDummyState(doc)
   117  
   118  	c.Check(result.DeviceName(), gc.Equals, "eth0")
   119  	c.Check(result.MachineID(), gc.Equals, "42")
   120  	c.Check(result.SubnetCIDR(), gc.Equals, "10.20.30.0/24")
   121  	c.Check(result.ConfigMethod(), gc.Equals, StaticAddress)
   122  	c.Check(result.Value(), gc.Equals, "10.20.30.40")
   123  	c.Check(result.DNSServers(), jc.DeepEquals, []string{"ns1.example.com", "ns2.example.org"})
   124  	c.Check(result.DNSSearchDomains(), jc.DeepEquals, []string{"example.com", "example.org"})
   125  	c.Check(result.GatewayAddress(), gc.Equals, "10.20.30.1")
   126  }
   127  
   128  func (s *ipAddressesInternalSuite) TestIsValidAddressConfigMethodWithValidValues(c *gc.C) {
   129  	validTypes := []AddressConfigMethod{
   130  		LoopbackAddress,
   131  		StaticAddress,
   132  		DynamicAddress,
   133  		ManualAddress,
   134  	}
   135  
   136  	for _, value := range validTypes {
   137  		result := IsValidAddressConfigMethod(string(value))
   138  		c.Check(result, jc.IsTrue)
   139  	}
   140  }
   141  
   142  func (s *ipAddressesInternalSuite) TestIsValidAddressConfigMethodWithInvalidValues(c *gc.C) {
   143  	result := IsValidAddressConfigMethod("")
   144  	c.Check(result, jc.IsFalse)
   145  
   146  	result = IsValidAddressConfigMethod("anything")
   147  	c.Check(result, jc.IsFalse)
   148  
   149  	result = IsValidAddressConfigMethod(" ")
   150  	c.Check(result, jc.IsFalse)
   151  }