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 }