github.com/infobloxopen/infoblox-go-client@v1.1.1/object_manager_test.go (about) 1 package ibclient 2 3 import ( 4 "errors" 5 6 . "github.com/onsi/ginkgo" 7 . "github.com/onsi/gomega" 8 9 "fmt" 10 ) 11 12 type fakeConnector struct { 13 createObjectObj interface{} 14 15 getObjectObj interface{} 16 getObjectRef string 17 18 deleteObjectRef string 19 20 updateObjectObj interface{} 21 updateObjectRef string 22 23 resultObject interface{} 24 25 fakeRefReturn string 26 } 27 28 func (c *fakeConnector) CreateObject(obj IBObject) (string, error) { 29 Expect(obj).To(Equal(c.createObjectObj)) 30 31 return c.fakeRefReturn, nil 32 } 33 34 func (c *fakeConnector) GetObject(obj IBObject, ref string, res interface{}) (err error) { 35 Expect(obj).To(Equal(c.getObjectObj)) 36 Expect(ref).To(Equal(c.getObjectRef)) 37 38 if ref == "" { 39 switch obj.(type) { 40 case *NetworkView: 41 *res.(*[]NetworkView) = c.resultObject.([]NetworkView) 42 case *NetworkContainer: 43 *res.(*[]NetworkContainer) = c.resultObject.([]NetworkContainer) 44 case *Network: 45 *res.(*[]Network) = c.resultObject.([]Network) 46 case *FixedAddress: 47 *res.(*[]FixedAddress) = c.resultObject.([]FixedAddress) 48 case *EADefinition: 49 *res.(*[]EADefinition) = c.resultObject.([]EADefinition) 50 case *CapacityReport: 51 *res.(*[]CapacityReport) = c.resultObject.([]CapacityReport) 52 case *UpgradeStatus: 53 *res.(*[]UpgradeStatus) = c.resultObject.([]UpgradeStatus) 54 case *Member: 55 *res.(*[]Member) = c.resultObject.([]Member) 56 case *Grid: 57 *res.(*[]Grid) = c.resultObject.([]Grid) 58 case *License: 59 *res.(*[]License) = c.resultObject.([]License) 60 case *HostRecord: 61 *res.(*[]HostRecord) = c.resultObject.([]HostRecord) 62 case *ZoneDelegated: 63 *res.(*[]ZoneDelegated) = c.resultObject.([]ZoneDelegated) 64 } 65 } else { 66 switch obj.(type) { 67 case *ZoneAuth: 68 *res.(*ZoneAuth) = c.resultObject.(ZoneAuth) 69 case *NetworkView: 70 *res.(*NetworkView) = c.resultObject.(NetworkView) 71 } 72 } 73 74 err = nil 75 return 76 } 77 78 func (c *fakeConnector) DeleteObject(ref string) (string, error) { 79 Expect(ref).To(Equal(c.deleteObjectRef)) 80 81 return c.fakeRefReturn, nil 82 } 83 84 func (c *fakeConnector) UpdateObject(obj IBObject, ref string) (string, error) { 85 Expect(obj).To(Equal(c.updateObjectObj)) 86 Expect(ref).To(Equal(c.updateObjectRef)) 87 88 return c.fakeRefReturn, nil 89 } 90 91 var _ = Describe("Object Manager", func() { 92 93 Describe("Create Network View", func() { 94 cmpType := "Docker" 95 tenantID := "01234567890abcdef01234567890abcdef" 96 netviewName := "Default View" 97 fakeRefReturn := "networkview/ZG5zLm5ldHdvcmtfdmlldyQyMw:global_view/false" 98 nvFakeConnector := &fakeConnector{ 99 createObjectObj: NewNetworkView(NetworkView{Name: netviewName}), 100 resultObject: NewNetworkView(NetworkView{Name: netviewName, Ref: fakeRefReturn}), 101 fakeRefReturn: fakeRefReturn, 102 } 103 104 objMgr := NewObjectManager(nvFakeConnector, cmpType, tenantID) 105 nvFakeConnector.createObjectObj.(*NetworkView).Ea = objMgr.getBasicEA(false) 106 nvFakeConnector.resultObject.(*NetworkView).Ea = objMgr.getBasicEA(false) 107 108 var actualNetworkView *NetworkView 109 var err error 110 It("should pass expected NetworkView Object to CreateObject", func() { 111 actualNetworkView, err = objMgr.CreateNetworkView(netviewName) 112 }) 113 It("should return expected NetworkView Object", func() { 114 Expect(actualNetworkView).To(Equal(nvFakeConnector.resultObject)) 115 Expect(err).To(BeNil()) 116 }) 117 }) 118 119 Describe("Update Network View", func() { 120 cmpType := "Docker" 121 tenantID := "01234567890abcdef01234567890abcdef" 122 netviewName := "Global View" 123 fakeRefReturn := "networkview/ZG5zLm5ldHdvcmtfdmlldyQyMw:global_view/false" 124 125 returnGetObject := NetworkView{Name: netviewName, Ref: fakeRefReturn, Ea: EA{"network-name": "net1", "Lock": "Removed"}} 126 returnUpdateObject := NetworkView{Name: netviewName, Ref: fakeRefReturn, Ea: EA{"network-name": "net2", "New": "Added"}} 127 getObjectObj := &NetworkView{} 128 getObjectObj.returnFields = []string{"extattrs"} 129 nvFakeConnector := &fakeConnector{ 130 getObjectObj: getObjectObj, 131 getObjectRef: fakeRefReturn, 132 fakeRefReturn: fakeRefReturn, 133 resultObject: returnGetObject, 134 updateObjectObj: &returnUpdateObject, 135 updateObjectRef: fakeRefReturn, 136 } 137 138 objMgr := NewObjectManager(nvFakeConnector, cmpType, tenantID) 139 140 var err error 141 It("should pass expected updated object to UpdateObject", func() { 142 addEA := EA{"network-name": "net2", "New": "Added"} 143 delEA := EA{"Lock": "Removed"} 144 err = objMgr.UpdateNetworkViewEA(fakeRefReturn, addEA, delEA) 145 }) 146 It("should updated the GetObject with new EA and with no error", func() { 147 Expect(returnGetObject).To(Equal(returnUpdateObject)) 148 Expect(err).To(BeNil()) 149 }) 150 }) 151 152 Describe("Create Network Container", func() { 153 cmpType := "Docker" 154 tenantID := "01234567890abcdef01234567890abcdef" 155 netviewName := "Default View" 156 cidr := "43.0.11.0/24" 157 fakeRefReturn := "networkcontainer/ZG5zLm5ldHdvcmtfdmlldyQyMw:global_view/false" 158 ncFakeConnector := &fakeConnector{ 159 createObjectObj: NewNetworkContainer(NetworkContainer{NetviewName: netviewName, Cidr: cidr}), 160 resultObject: NewNetworkContainer(NetworkContainer{NetviewName: netviewName, Cidr: cidr, Ref: fakeRefReturn}), 161 fakeRefReturn: fakeRefReturn, 162 } 163 164 objMgr := NewObjectManager(ncFakeConnector, cmpType, tenantID) 165 ncFakeConnector.createObjectObj.(*NetworkContainer).Ea = objMgr.getBasicEA(true) 166 ncFakeConnector.resultObject.(*NetworkContainer).Ea = objMgr.getBasicEA(true) 167 168 var actualNetworkContainer *NetworkContainer 169 var err error 170 It("should pass expected NetworkContainer Object to CreateObject", func() { 171 actualNetworkContainer, err = objMgr.CreateNetworkContainer(netviewName, cidr) 172 }) 173 It("should return expected NetworkContainer Object", func() { 174 Expect(actualNetworkContainer).To(Equal(ncFakeConnector.resultObject)) 175 Expect(err).To(BeNil()) 176 }) 177 }) 178 179 Describe("Create Network", func() { 180 cmpType := "Docker" 181 tenantID := "01234567890abcdef01234567890abcdef" 182 netviewName := "default_view" 183 cidr := "43.0.11.0/24" 184 networkName := "private-net" 185 fakeRefReturn := "network/ZG5zLm5ldHdvcmskODkuMC4wLjAvMjQvMjU:43.0.11.0/24/default_view" 186 nwFakeConnector := &fakeConnector{ 187 createObjectObj: NewNetwork(Network{NetviewName: netviewName, Cidr: cidr}), 188 resultObject: NewNetwork(Network{NetviewName: netviewName, Cidr: cidr, Ref: fakeRefReturn}), 189 fakeRefReturn: fakeRefReturn, 190 } 191 192 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 193 194 nwFakeConnector.createObjectObj.(*Network).Ea = objMgr.getBasicEA(true) 195 nwFakeConnector.createObjectObj.(*Network).Ea["Network Name"] = networkName 196 197 nwFakeConnector.resultObject.(*Network).Ea = objMgr.getBasicEA(true) 198 nwFakeConnector.resultObject.(*Network).Ea["Network Name"] = networkName 199 200 var actualNetwork *Network 201 var err error 202 It("should pass expected Network Object to CreateObject", func() { 203 actualNetwork, err = objMgr.CreateNetwork(netviewName, cidr, networkName) 204 }) 205 It("should return expected Network Object", func() { 206 Expect(actualNetwork).To(Equal(nwFakeConnector.resultObject)) 207 Expect(err).To(BeNil()) 208 }) 209 }) 210 211 Describe("Allocate Network", func() { 212 cmpType := "Docker" 213 tenantID := "01234567890abcdef01234567890abcdef" 214 netviewName := "default_view" 215 cidr := "142.0.22.0/24" 216 prefixLen := uint(24) 217 networkName := "private-net" 218 fakeRefReturn := fmt.Sprintf("network/ZG5zLm5ldHdvcmskODkuMC4wLjAvMjQvMjU:%s/%s", cidr, netviewName) 219 anFakeConnector := &fakeConnector{ 220 createObjectObj: NewNetwork(Network{ 221 NetviewName: netviewName, 222 Cidr: fmt.Sprintf("func:nextavailablenetwork:%s,%s,%d", cidr, netviewName, prefixLen), 223 }), 224 resultObject: BuildNetworkFromRef(fakeRefReturn), 225 fakeRefReturn: fakeRefReturn, 226 } 227 228 objMgr := NewObjectManager(anFakeConnector, cmpType, tenantID) 229 230 anFakeConnector.createObjectObj.(*Network).Ea = objMgr.getBasicEA(true) 231 anFakeConnector.createObjectObj.(*Network).Ea["Network Name"] = networkName 232 233 var actualNetwork *Network 234 var err error 235 It("should pass expected Network Object to CreateObject", func() { 236 actualNetwork, err = objMgr.AllocateNetwork(netviewName, cidr, prefixLen, networkName) 237 }) 238 It("should return expected Network Object", func() { 239 Expect(actualNetwork).To(Equal(anFakeConnector.resultObject)) 240 Expect(err).To(BeNil()) 241 }) 242 }) 243 244 Describe("Allocate Specific IP", func() { 245 cmpType := "Docker" 246 tenantID := "01234567890abcdef01234567890abcdef" 247 netviewName := "private" 248 cidr := "53.0.0.0/24" 249 ipAddr := "53.0.0.21" 250 macAddr := "01:23:45:67:80:ab" 251 vmID := "93f9249abc039284" 252 vmName := "dummyvm" 253 name := "testvm" 254 fakeRefReturn := fmt.Sprintf("fixedaddress/ZG5zLmJpbmRfY25h:%s/private", ipAddr) 255 256 asiFakeConnector := &fakeConnector{ 257 createObjectObj: NewFixedAddress(FixedAddress{ 258 NetviewName: netviewName, 259 Cidr: cidr, 260 IPAddress: ipAddr, 261 Mac: macAddr, 262 Name: name, 263 }), 264 resultObject: NewFixedAddress(FixedAddress{ 265 NetviewName: netviewName, 266 Cidr: cidr, 267 IPAddress: GetIPAddressFromRef(fakeRefReturn), 268 Mac: macAddr, 269 Ref: fakeRefReturn, 270 Name: name, 271 }), 272 fakeRefReturn: fakeRefReturn, 273 } 274 275 objMgr := NewObjectManager(asiFakeConnector, cmpType, tenantID) 276 277 ea := objMgr.getBasicEA(true) 278 asiFakeConnector.createObjectObj.(*FixedAddress).Ea = ea 279 asiFakeConnector.createObjectObj.(*FixedAddress).Ea["VM ID"] = vmID 280 asiFakeConnector.createObjectObj.(*FixedAddress).Ea["VM Name"] = vmName 281 282 asiFakeConnector.resultObject.(*FixedAddress).Ea = ea 283 asiFakeConnector.resultObject.(*FixedAddress).Ea["VM ID"] = vmID 284 asiFakeConnector.resultObject.(*FixedAddress).Ea["VM Name"] = vmName 285 286 var actualIP *FixedAddress 287 var err error 288 It("should pass expected Fixed Address Object to CreateObject", func() { 289 actualIP, err = objMgr.AllocateIP(netviewName, cidr, ipAddr, macAddr, name, ea) 290 }) 291 It("should return expected Fixed Address Object", func() { 292 Expect(actualIP).To(Equal(asiFakeConnector.resultObject)) 293 Expect(err).To(BeNil()) 294 }) 295 }) 296 297 Describe("Allocate Next Available IP", func() { 298 cmpType := "Docker" 299 tenantID := "01234567890abcdef01234567890abcdef" 300 netviewName := "private" 301 cidr := "53.0.0.0/24" 302 ipAddr := fmt.Sprintf("func:nextavailableip:%s,%s", cidr, netviewName) 303 macAddr := "01:23:45:67:80:ab" 304 vmID := "93f9249abc039284" 305 name := "testvm" 306 vmName := "dummyvm" 307 resultIP := "53.0.0.32" 308 fakeRefReturn := fmt.Sprintf("fixedaddress/ZG5zLmJpbmRfY25h:%s/private", resultIP) 309 310 aniFakeConnector := &fakeConnector{ 311 createObjectObj: NewFixedAddress(FixedAddress{ 312 NetviewName: netviewName, 313 Cidr: cidr, 314 IPAddress: ipAddr, 315 Mac: macAddr, 316 Name: name, 317 }), 318 resultObject: NewFixedAddress(FixedAddress{ 319 NetviewName: netviewName, 320 Cidr: cidr, 321 IPAddress: resultIP, 322 Mac: macAddr, 323 Ref: fakeRefReturn, 324 Name: name, 325 }), 326 fakeRefReturn: fakeRefReturn, 327 } 328 329 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 330 331 ea := objMgr.getBasicEA(true) 332 aniFakeConnector.createObjectObj.(*FixedAddress).Ea = ea 333 aniFakeConnector.createObjectObj.(*FixedAddress).Ea["VM ID"] = vmID 334 aniFakeConnector.createObjectObj.(*FixedAddress).Ea["VM Name"] = vmName 335 336 aniFakeConnector.resultObject.(*FixedAddress).Ea = ea 337 aniFakeConnector.resultObject.(*FixedAddress).Ea["VM ID"] = vmID 338 aniFakeConnector.resultObject.(*FixedAddress).Ea["VM Name"] = vmName 339 340 var actualIP *FixedAddress 341 var err error 342 It("should pass expected Fixed Address Object to CreateObject", func() { 343 actualIP, err = objMgr.AllocateIP(netviewName, cidr, ipAddr, macAddr, name, ea) 344 }) 345 346 It("should return expected Fixed Address Object", func() { 347 Expect(actualIP).To(Equal(aniFakeConnector.resultObject)) 348 Expect(err).To(BeNil()) 349 }) 350 }) 351 352 Describe("Allocate next available host Record without dns", func() { 353 cmpType := "Docker" 354 tenantID := "01234567890abcdef01234567890abcdef" 355 netviewName := "private" 356 cidr := "53.0.0.0/24" 357 macAddr := "01:23:45:67:80:ab" 358 ipAddr := fmt.Sprintf("func:nextavailableip:%s,%s", cidr, netviewName) 359 vmID := "93f9249abc039284" 360 vmName := "dummyvm" 361 recordName := "test" 362 enabledns := false 363 dnsView := "default" 364 fakeRefReturn := fmt.Sprintf("record:host/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 365 resultIPV4Addrs := NewHostRecordIpv4Addr(HostRecordIpv4Addr{Ipv4Addr: ipAddr, Mac: macAddr}) 366 enableDNS := new(bool) 367 *enableDNS = enabledns 368 369 aniFakeConnector := &fakeConnector{ 370 createObjectObj: NewHostRecord(HostRecord{ 371 Name: recordName, 372 View: dnsView, 373 EnableDns: enableDNS, 374 NetworkView: netviewName, 375 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 376 }), 377 getObjectRef: fakeRefReturn, 378 getObjectObj: NewHostRecord(HostRecord{ 379 Name: recordName, 380 View: dnsView, 381 EnableDns: enableDNS, 382 NetworkView: netviewName, 383 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 384 Ref: fakeRefReturn, 385 }), 386 resultObject: NewHostRecord(HostRecord{ 387 Name: recordName, 388 View: dnsView, 389 EnableDns: enableDNS, 390 NetworkView: netviewName, 391 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 392 Ref: fakeRefReturn, 393 }), 394 fakeRefReturn: fakeRefReturn, 395 } 396 397 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 398 399 ea := objMgr.getBasicEA(true) 400 aniFakeConnector.createObjectObj.(*HostRecord).Ea = ea 401 aniFakeConnector.createObjectObj.(*HostRecord).Ea["VM ID"] = vmID 402 aniFakeConnector.createObjectObj.(*HostRecord).Ea["VM Name"] = vmName 403 404 aniFakeConnector.resultObject.(*HostRecord).Ea = ea 405 aniFakeConnector.resultObject.(*HostRecord).Ea["VM ID"] = vmID 406 aniFakeConnector.resultObject.(*HostRecord).Ea["VM Name"] = vmName 407 408 aniFakeConnector.getObjectObj.(*HostRecord).Ea = ea 409 aniFakeConnector.getObjectObj.(*HostRecord).Ea["VM ID"] = vmID 410 aniFakeConnector.getObjectObj.(*HostRecord).Ea["VM Name"] = vmName 411 412 var actualRecord *HostRecord 413 var err error 414 It("should pass expected host record Object to CreateObject", func() { 415 actualRecord, err = objMgr.CreateHostRecord(enabledns, recordName, netviewName, dnsView, cidr, ipAddr, macAddr, ea) 416 }) 417 It("should return expected host record Object", func() { 418 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 419 Expect(err).To(BeNil()) 420 }) 421 }) 422 423 Describe("Allocate next available host Record with dns", func() { 424 cmpType := "Docker" 425 tenantID := "01234567890abcdef01234567890abcdef" 426 netviewName := "private" 427 cidr := "53.0.0.0/24" 428 macAddr := "01:23:45:67:80:ab" 429 ipAddr := fmt.Sprintf("func:nextavailableip:%s,%s", cidr, netviewName) 430 vmID := "93f9249abc039284" 431 vmName := "dummyvm" 432 recordName := "test" 433 enabledns := true 434 dnsView := "default" 435 fakeRefReturn := fmt.Sprintf("record:host/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 436 resultIPV4Addrs := NewHostRecordIpv4Addr(HostRecordIpv4Addr{Ipv4Addr: ipAddr, Mac: macAddr}) 437 enableDNS := new(bool) 438 *enableDNS = enabledns 439 440 aniFakeConnector := &fakeConnector{ 441 createObjectObj: NewHostRecord(HostRecord{ 442 Name: recordName, 443 View: dnsView, 444 EnableDns: enableDNS, 445 NetworkView: netviewName, 446 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 447 }), 448 getObjectRef: fakeRefReturn, 449 getObjectObj: NewHostRecord(HostRecord{ 450 Name: recordName, 451 View: dnsView, 452 EnableDns: enableDNS, 453 NetworkView: netviewName, 454 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 455 Ref: fakeRefReturn, 456 }), 457 resultObject: NewHostRecord(HostRecord{ 458 Name: recordName, 459 View: dnsView, 460 EnableDns: enableDNS, 461 NetworkView: netviewName, 462 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 463 Ref: fakeRefReturn, 464 }), 465 fakeRefReturn: fakeRefReturn, 466 } 467 468 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 469 470 ea := objMgr.getBasicEA(true) 471 aniFakeConnector.createObjectObj.(*HostRecord).Ea = ea 472 aniFakeConnector.createObjectObj.(*HostRecord).Ea["VM ID"] = vmID 473 aniFakeConnector.createObjectObj.(*HostRecord).Ea["VM Name"] = vmName 474 475 aniFakeConnector.resultObject.(*HostRecord).Ea = ea 476 aniFakeConnector.resultObject.(*HostRecord).Ea["VM ID"] = vmID 477 aniFakeConnector.resultObject.(*HostRecord).Ea["VM Name"] = vmName 478 479 aniFakeConnector.getObjectObj.(*HostRecord).Ea = ea 480 aniFakeConnector.getObjectObj.(*HostRecord).Ea["VM ID"] = vmID 481 aniFakeConnector.getObjectObj.(*HostRecord).Ea["VM Name"] = vmName 482 483 var actualRecord *HostRecord 484 var err error 485 It("should pass expected host record Object to CreateObject", func() { 486 actualRecord, err = objMgr.CreateHostRecord(enabledns, recordName, netviewName, dnsView, cidr, ipAddr, macAddr, ea) 487 }) 488 It("should return expected host record Object", func() { 489 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 490 Expect(err).To(BeNil()) 491 }) 492 }) 493 494 Describe("Allocate specific host Record without dns", func() { 495 cmpType := "Docker" 496 tenantID := "01234567890abcdef01234567890abcdef" 497 netviewName := "private" 498 cidr := "53.0.0.0/24" 499 macAddr := "01:23:45:67:80:ab" 500 ipAddr := "53.0.0.1" 501 vmID := "93f9249abc039284" 502 vmName := "dummyvm" 503 enabledns := false 504 dnsView := "default" 505 recordName := "test" 506 fakeRefReturn := fmt.Sprintf("record:host/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 507 resultIPV4Addrs := NewHostRecordIpv4Addr(HostRecordIpv4Addr{Ipv4Addr: ipAddr, Mac: macAddr}) 508 enableDNS := new(bool) 509 *enableDNS = enabledns 510 511 aniFakeConnector := &fakeConnector{ 512 createObjectObj: NewHostRecord(HostRecord{ 513 Name: recordName, 514 View: dnsView, 515 EnableDns: enableDNS, 516 NetworkView: netviewName, 517 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 518 }), 519 getObjectRef: fakeRefReturn, 520 getObjectObj: NewHostRecord(HostRecord{ 521 Name: recordName, 522 EnableDns: enableDNS, 523 View: dnsView, 524 NetworkView: netviewName, 525 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 526 Ref: fakeRefReturn, 527 }), 528 resultObject: NewHostRecord(HostRecord{ 529 Name: recordName, 530 EnableDns: enableDNS, 531 View: dnsView, 532 NetworkView: netviewName, 533 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 534 Ref: fakeRefReturn, 535 }), 536 fakeRefReturn: fakeRefReturn, 537 } 538 539 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 540 541 ea := objMgr.getBasicEA(true) 542 aniFakeConnector.createObjectObj.(*HostRecord).Ea = ea 543 aniFakeConnector.createObjectObj.(*HostRecord).Ea["VM ID"] = vmID 544 aniFakeConnector.createObjectObj.(*HostRecord).Ea["VM Name"] = vmName 545 546 aniFakeConnector.resultObject.(*HostRecord).Ea = ea 547 aniFakeConnector.resultObject.(*HostRecord).Ea["VM ID"] = vmID 548 aniFakeConnector.resultObject.(*HostRecord).Ea["VM Name"] = vmName 549 550 aniFakeConnector.getObjectObj.(*HostRecord).Ea = ea 551 aniFakeConnector.getObjectObj.(*HostRecord).Ea["VM ID"] = vmID 552 aniFakeConnector.getObjectObj.(*HostRecord).Ea["VM Name"] = vmName 553 554 var actualRecord *HostRecord 555 var err error 556 It("should pass expected host record Object to CreateObject", func() { 557 actualRecord, err = objMgr.CreateHostRecord(enabledns, recordName, netviewName, dnsView, cidr, ipAddr, macAddr, ea) 558 }) 559 560 It("should return expected host record Object", func() { 561 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 562 Expect(err).To(BeNil()) 563 }) 564 }) 565 566 Describe("Allocate specific host Record with dns", func() { 567 cmpType := "Docker" 568 tenantID := "01234567890abcdef01234567890abcdef" 569 netviewName := "private" 570 cidr := "53.0.0.0/24" 571 macAddr := "01:23:45:67:80:ab" 572 ipAddr := "53.0.0.1" 573 vmID := "93f9249abc039284" 574 vmName := "dummyvm" 575 enabledns := true 576 dnsView := "default" 577 recordName := "test" 578 fakeRefReturn := fmt.Sprintf("record:host/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 579 resultIPV4Addrs := NewHostRecordIpv4Addr(HostRecordIpv4Addr{Ipv4Addr: ipAddr, Mac: macAddr}) 580 enableDNS := new(bool) 581 *enableDNS = enabledns 582 583 aniFakeConnector := &fakeConnector{ 584 createObjectObj: NewHostRecord(HostRecord{ 585 Name: recordName, 586 View: dnsView, 587 EnableDns: enableDNS, 588 NetworkView: netviewName, 589 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 590 }), 591 getObjectRef: fakeRefReturn, 592 getObjectObj: NewHostRecord(HostRecord{ 593 Name: recordName, 594 EnableDns: enableDNS, 595 View: dnsView, 596 NetworkView: netviewName, 597 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 598 Ref: fakeRefReturn, 599 }), 600 resultObject: NewHostRecord(HostRecord{ 601 Name: recordName, 602 EnableDns: enableDNS, 603 View: dnsView, 604 NetworkView: netviewName, 605 Ipv4Addrs: []HostRecordIpv4Addr{*resultIPV4Addrs}, 606 Ref: fakeRefReturn, 607 }), 608 fakeRefReturn: fakeRefReturn, 609 } 610 611 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 612 613 ea := objMgr.getBasicEA(true) 614 aniFakeConnector.createObjectObj.(*HostRecord).Ea = ea 615 aniFakeConnector.createObjectObj.(*HostRecord).Ea["VM ID"] = vmID 616 aniFakeConnector.createObjectObj.(*HostRecord).Ea["VM Name"] = vmName 617 618 aniFakeConnector.resultObject.(*HostRecord).Ea = ea 619 aniFakeConnector.resultObject.(*HostRecord).Ea["VM ID"] = vmID 620 aniFakeConnector.resultObject.(*HostRecord).Ea["VM Name"] = vmName 621 622 aniFakeConnector.getObjectObj.(*HostRecord).Ea = ea 623 aniFakeConnector.getObjectObj.(*HostRecord).Ea["VM ID"] = vmID 624 aniFakeConnector.getObjectObj.(*HostRecord).Ea["VM Name"] = vmName 625 626 var actualRecord *HostRecord 627 var err error 628 It("should pass expected host record Object to CreateObject", func() { 629 actualRecord, err = objMgr.CreateHostRecord(enabledns, recordName, netviewName, dnsView, cidr, ipAddr, macAddr, ea) 630 }) 631 632 It("should return expected host record Object", func() { 633 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 634 Expect(err).To(BeNil()) 635 }) 636 }) 637 638 Describe("Allocate specific A Record ", func() { 639 cmpType := "Docker" 640 tenantID := "01234567890abcdef01234567890abcdef" 641 netviewName := "private" 642 cidr := "53.0.0.0/24" 643 ipAddr := "53.0.0.1" 644 vmID := "93f9249abc039284" 645 vmName := "dummyvm" 646 dnsView := "default" 647 recordName := "test" 648 fakeRefReturn := fmt.Sprintf("record:a/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 649 aniFakeConnector := &fakeConnector{ 650 createObjectObj: NewRecordA(RecordA{ 651 Name: recordName, 652 View: dnsView, 653 Ipv4Addr: ipAddr, 654 }), 655 getObjectRef: fakeRefReturn, 656 getObjectObj: NewRecordA(RecordA{ 657 Name: recordName, 658 View: dnsView, 659 Ipv4Addr: ipAddr, 660 Ref: fakeRefReturn, 661 }), 662 resultObject: NewRecordA(RecordA{ 663 Name: recordName, 664 View: dnsView, 665 Ipv4Addr: ipAddr, 666 Ref: fakeRefReturn, 667 }), 668 fakeRefReturn: fakeRefReturn, 669 } 670 671 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 672 673 ea := objMgr.getBasicEA(true) 674 aniFakeConnector.createObjectObj.(*RecordA).Ea = ea 675 aniFakeConnector.createObjectObj.(*RecordA).Ea["VM ID"] = vmID 676 aniFakeConnector.createObjectObj.(*RecordA).Ea["VM Name"] = vmName 677 678 aniFakeConnector.resultObject.(*RecordA).Ea = ea 679 aniFakeConnector.resultObject.(*RecordA).Ea["VM ID"] = vmID 680 aniFakeConnector.resultObject.(*RecordA).Ea["VM Name"] = vmName 681 682 aniFakeConnector.getObjectObj.(*RecordA).Ea = ea 683 aniFakeConnector.getObjectObj.(*RecordA).Ea["VM ID"] = vmID 684 aniFakeConnector.getObjectObj.(*RecordA).Ea["VM Name"] = vmName 685 686 var actualRecord *RecordA 687 var err error 688 It("should pass expected A record Object to CreateObject", func() { 689 actualRecord, err = objMgr.CreateARecord(netviewName, dnsView, recordName, cidr, ipAddr, ea) 690 }) 691 It("should return expected A record Object", func() { 692 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 693 Expect(err).To(BeNil()) 694 }) 695 }) 696 697 Describe("Allocate next available A Record ", func() { 698 cmpType := "Docker" 699 tenantID := "01234567890abcdef01234567890abcdef" 700 netviewName := "private" 701 cidr := "53.0.0.0/24" 702 ipAddr := fmt.Sprintf("func:nextavailableip:%s,%s", cidr, netviewName) 703 vmID := "93f9249abc039284" 704 vmName := "dummyvm" 705 dnsView := "default" 706 recordName := "test" 707 fakeRefReturn := fmt.Sprintf("record:a/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 708 709 aniFakeConnector := &fakeConnector{ 710 createObjectObj: NewRecordA(RecordA{ 711 Name: recordName, 712 View: dnsView, 713 Ipv4Addr: ipAddr, 714 }), 715 getObjectRef: fakeRefReturn, 716 getObjectObj: NewRecordA(RecordA{ 717 Name: recordName, 718 View: dnsView, 719 Ipv4Addr: ipAddr, 720 Ref: fakeRefReturn, 721 }), 722 resultObject: NewRecordA(RecordA{ 723 Name: recordName, 724 View: dnsView, 725 Ipv4Addr: ipAddr, 726 Ref: fakeRefReturn, 727 }), 728 fakeRefReturn: fakeRefReturn, 729 } 730 731 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 732 733 ea := objMgr.getBasicEA(true) 734 aniFakeConnector.createObjectObj.(*RecordA).Ea = ea 735 aniFakeConnector.createObjectObj.(*RecordA).Ea["VM ID"] = vmID 736 aniFakeConnector.createObjectObj.(*RecordA).Ea["VM Name"] = vmName 737 738 aniFakeConnector.resultObject.(*RecordA).Ea = ea 739 aniFakeConnector.resultObject.(*RecordA).Ea["VM ID"] = vmID 740 aniFakeConnector.resultObject.(*RecordA).Ea["VM Name"] = vmName 741 742 aniFakeConnector.getObjectObj.(*RecordA).Ea = ea 743 aniFakeConnector.getObjectObj.(*RecordA).Ea["VM ID"] = vmID 744 aniFakeConnector.getObjectObj.(*RecordA).Ea["VM Name"] = vmName 745 746 var actualRecord *RecordA 747 var err error 748 It("should pass expected A record Object to CreateObject", func() { 749 actualRecord, err = objMgr.CreateARecord(netviewName, dnsView, recordName, cidr, ipAddr, ea) 750 }) 751 It("should return expected A record Object", func() { 752 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 753 Expect(err).To(BeNil()) 754 }) 755 }) 756 757 Describe("Allocate specific PTR Record ", func() { 758 cmpType := "Docker" 759 tenantID := "01234567890abcdef01234567890abcdef" 760 netviewName := "private" 761 cidr := "53.0.0.0/24" 762 ipAddr := "53.0.0.1" 763 vmID := "93f9249abc039284" 764 vmName := "dummyvm" 765 dnsView := "default" 766 recordName := "test" 767 fakeRefReturn := fmt.Sprintf("record:ptr/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 768 769 aniFakeConnector := &fakeConnector{ 770 createObjectObj: NewRecordPTR(RecordPTR{ 771 PtrdName: recordName, 772 View: dnsView, 773 Ipv4Addr: ipAddr, 774 }), 775 getObjectRef: fakeRefReturn, 776 getObjectObj: NewRecordPTR(RecordPTR{ 777 PtrdName: recordName, 778 View: dnsView, 779 Ipv4Addr: ipAddr, 780 Ref: fakeRefReturn, 781 }), 782 resultObject: NewRecordPTR(RecordPTR{ 783 PtrdName: recordName, 784 View: dnsView, 785 Ipv4Addr: ipAddr, 786 Ref: fakeRefReturn, 787 }), 788 fakeRefReturn: fakeRefReturn, 789 } 790 791 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 792 793 ea := objMgr.getBasicEA(true) 794 aniFakeConnector.createObjectObj.(*RecordPTR).Ea = ea 795 aniFakeConnector.createObjectObj.(*RecordPTR).Ea["VM ID"] = vmID 796 aniFakeConnector.createObjectObj.(*RecordPTR).Ea["VM Name"] = vmName 797 798 aniFakeConnector.resultObject.(*RecordPTR).Ea = ea 799 aniFakeConnector.resultObject.(*RecordPTR).Ea["VM ID"] = vmID 800 aniFakeConnector.resultObject.(*RecordPTR).Ea["VM Name"] = vmName 801 802 aniFakeConnector.getObjectObj.(*RecordPTR).Ea = ea 803 aniFakeConnector.getObjectObj.(*RecordPTR).Ea["VM ID"] = vmID 804 aniFakeConnector.getObjectObj.(*RecordPTR).Ea["VM Name"] = vmName 805 806 var actualRecord *RecordPTR 807 var err error 808 It("should pass expected PTR record Object to CreateObject", func() { 809 actualRecord, err = objMgr.CreatePTRRecord(netviewName, dnsView, recordName, cidr, ipAddr, ea) 810 }) 811 It("should return expected PTR record Object", func() { 812 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 813 Expect(err).To(BeNil()) 814 }) 815 }) 816 817 Describe("Allocate next available PTR Record ", func() { 818 cmpType := "Docker" 819 tenantID := "01234567890abcdef01234567890abcdef" 820 netviewName := "private" 821 cidr := "53.0.0.0/24" 822 ipAddr := fmt.Sprintf("func:nextavailableip:%s,%s", cidr, netviewName) 823 vmID := "93f9249abc039284" 824 vmName := "dummyvm" 825 dnsView := "default" 826 recordName := "test" 827 fakeRefReturn := fmt.Sprintf("record:ptr/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 828 829 aniFakeConnector := &fakeConnector{ 830 createObjectObj: NewRecordPTR(RecordPTR{ 831 PtrdName: recordName, 832 View: dnsView, 833 Ipv4Addr: ipAddr, 834 }), 835 getObjectRef: fakeRefReturn, 836 getObjectObj: NewRecordPTR(RecordPTR{ 837 PtrdName: recordName, 838 View: dnsView, 839 Ipv4Addr: ipAddr, 840 Ref: fakeRefReturn, 841 }), 842 resultObject: NewRecordPTR(RecordPTR{ 843 PtrdName: recordName, 844 View: dnsView, 845 Ipv4Addr: ipAddr, 846 Ref: fakeRefReturn, 847 }), 848 fakeRefReturn: fakeRefReturn, 849 } 850 851 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 852 853 ea := objMgr.getBasicEA(true) 854 aniFakeConnector.createObjectObj.(*RecordPTR).Ea = ea 855 aniFakeConnector.createObjectObj.(*RecordPTR).Ea["VM ID"] = vmID 856 aniFakeConnector.createObjectObj.(*RecordPTR).Ea["VM Name"] = vmName 857 858 aniFakeConnector.resultObject.(*RecordPTR).Ea = ea 859 aniFakeConnector.resultObject.(*RecordPTR).Ea["VM ID"] = vmID 860 aniFakeConnector.resultObject.(*RecordPTR).Ea["VM Name"] = vmName 861 862 aniFakeConnector.getObjectObj.(*RecordPTR).Ea = ea 863 aniFakeConnector.getObjectObj.(*RecordPTR).Ea["VM ID"] = vmID 864 aniFakeConnector.getObjectObj.(*RecordPTR).Ea["VM Name"] = vmName 865 866 var actualRecord *RecordPTR 867 var err error 868 It("should pass expected PTR record Object to CreateObject", func() { 869 actualRecord, err = objMgr.CreatePTRRecord(netviewName, dnsView, recordName, cidr, ipAddr, ea) 870 }) 871 It("should return expected PTR record Object", func() { 872 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 873 Expect(err).To(BeNil()) 874 }) 875 }) 876 877 Describe("Allocate CNAME Record ", func() { 878 cmpType := "Docker" 879 tenantID := "01234567890abcdef01234567890abcdef" 880 canonical := "test-canonical" 881 dnsView := "default" 882 vmID := "93f9249abc039284" 883 vmName := "dummyvm" 884 recordName := "test" 885 fakeRefReturn := fmt.Sprintf("record:cname/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 886 887 aniFakeConnector := &fakeConnector{ 888 createObjectObj: NewRecordCNAME(RecordCNAME{ 889 Name: recordName, 890 View: dnsView, 891 Canonical: canonical, 892 }), 893 getObjectRef: fakeRefReturn, 894 getObjectObj: NewRecordCNAME(RecordCNAME{ 895 Name: recordName, 896 View: dnsView, 897 Canonical: canonical, 898 Ref: fakeRefReturn, 899 }), 900 resultObject: NewRecordCNAME(RecordCNAME{ 901 Name: recordName, 902 View: dnsView, 903 Canonical: canonical, 904 Ref: fakeRefReturn, 905 }), 906 fakeRefReturn: fakeRefReturn, 907 } 908 909 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 910 ea := objMgr.getBasicEA(true) 911 aniFakeConnector.createObjectObj.(*RecordCNAME).Ea = ea 912 aniFakeConnector.createObjectObj.(*RecordCNAME).Ea["VM ID"] = vmID 913 aniFakeConnector.createObjectObj.(*RecordCNAME).Ea["VM Name"] = vmName 914 915 aniFakeConnector.resultObject.(*RecordCNAME).Ea = ea 916 aniFakeConnector.resultObject.(*RecordCNAME).Ea["VM ID"] = vmID 917 aniFakeConnector.resultObject.(*RecordCNAME).Ea["VM Name"] = vmName 918 919 aniFakeConnector.getObjectObj.(*RecordCNAME).Ea = ea 920 aniFakeConnector.getObjectObj.(*RecordCNAME).Ea["VM ID"] = vmID 921 aniFakeConnector.getObjectObj.(*RecordCNAME).Ea["VM Name"] = vmName 922 var actualRecord *RecordCNAME 923 var err error 924 It("should pass expected CNAME record Object to CreateObject", func() { 925 actualRecord, err = objMgr.CreateCNAMERecord(canonical, recordName, dnsView, ea) 926 }) 927 It("should return expected CNAME record Object", func() { 928 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 929 Expect(err).To(BeNil()) 930 }) 931 }) 932 933 Describe("Allocate TXT Record ", func() { 934 cmpType := "Docker" 935 tenantID := "01234567890abcdef01234567890abcdef" 936 text := "test-text" 937 dnsView := "default" 938 recordName := "test" 939 ttl := uint(30) 940 fakeRefReturn := fmt.Sprintf("record:txt/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 941 942 aniFakeConnector := &fakeConnector{ 943 createObjectObj: NewRecordTXT(RecordTXT{ 944 Name: recordName, 945 Text: text, 946 Ttl: ttl, 947 View: dnsView, 948 }), 949 getObjectRef: fakeRefReturn, 950 getObjectObj: NewRecordTXT(RecordTXT{ 951 Name: recordName, 952 Text: text, 953 View: dnsView, 954 Ref: fakeRefReturn, 955 Ttl: ttl, 956 }), 957 resultObject: NewRecordTXT(RecordTXT{ 958 Name: recordName, 959 Text: text, 960 View: dnsView, 961 Ttl: ttl, 962 Ref: fakeRefReturn, 963 }), 964 fakeRefReturn: fakeRefReturn, 965 } 966 967 objMgr := NewObjectManager(aniFakeConnector, cmpType, tenantID) 968 969 var actualRecord *RecordTXT 970 var err error 971 It("should pass expected TXT record Object to CreateObject", func() { 972 actualRecord, err = objMgr.CreateTXTRecord(recordName, text, 30, dnsView) 973 }) 974 It("should return expected TXT record Object", func() { 975 Expect(actualRecord).To(Equal(aniFakeConnector.resultObject)) 976 Expect(err).To(BeNil()) 977 }) 978 }) 979 980 Describe("Create EA Definition", func() { 981 cmpType := "Docker" 982 tenantID := "01234567890abcdef01234567890abcdef" 983 comment := "Test Extensible Attribute" 984 flags := "CGV" 985 listValues := []EADefListValue{"True", "False"} 986 name := "TestEA" 987 eaType := "string" 988 allowedTypes := []string{"arecord", "aaarecord", "ptrrecord"} 989 ead := EADefinition{ 990 Name: name, 991 Comment: comment, 992 Flags: flags, 993 ListValues: listValues, 994 Type: eaType, 995 AllowedObjectTypes: allowedTypes} 996 fakeRefReturn := "extensibleattributedef/ZG5zLm5ldHdvcmtfdmlldyQyMw:TestEA" 997 eadFakeConnector := &fakeConnector{ 998 createObjectObj: NewEADefinition(ead), 999 resultObject: NewEADefinition(ead), 1000 fakeRefReturn: fakeRefReturn, 1001 } 1002 eadFakeConnector.resultObject.(*EADefinition).Ref = fakeRefReturn 1003 1004 objMgr := NewObjectManager(eadFakeConnector, cmpType, tenantID) 1005 1006 var actualEADef *EADefinition 1007 var err error 1008 It("should pass expected EA Definintion Object to CreateObject", func() { 1009 actualEADef, err = objMgr.CreateEADefinition(ead) 1010 }) 1011 It("should return expected EA Definition Object", func() { 1012 Expect(actualEADef).To(Equal(eadFakeConnector.resultObject)) 1013 Expect(err).To(BeNil()) 1014 }) 1015 }) 1016 1017 Describe("Get Network View", func() { 1018 cmpType := "Docker" 1019 tenantID := "01234567890abcdef01234567890abcdef" 1020 netviewName := "Default View" 1021 fakeRefReturn := "networkview/ZG5zLm5ldHdvcmtfdmlldyQyMw:global_view/false" 1022 nvFakeConnector := &fakeConnector{ 1023 getObjectObj: NewNetworkView(NetworkView{Name: netviewName}), 1024 getObjectRef: "", 1025 resultObject: []NetworkView{*NewNetworkView(NetworkView{Name: netviewName, Ref: fakeRefReturn})}, 1026 } 1027 1028 objMgr := NewObjectManager(nvFakeConnector, cmpType, tenantID) 1029 1030 var actualNetworkView *NetworkView 1031 var err error 1032 It("should pass expected NetworkView Object to GetObject", func() { 1033 actualNetworkView, err = objMgr.GetNetworkView(netviewName) 1034 }) 1035 It("should return expected NetworkView Object", func() { 1036 Expect(*actualNetworkView).To(Equal(nvFakeConnector.resultObject.([]NetworkView)[0])) 1037 Expect(err).To(BeNil()) 1038 }) 1039 }) 1040 1041 Describe("Get Network Container", func() { 1042 cmpType := "Docker" 1043 tenantID := "01234567890abcdef01234567890abcdef" 1044 netviewName := "Default View" 1045 cidr := "43.0.11.0/24" 1046 fakeRefReturn := "networkcontainer/ZG5zLm5ldHdvcmtfdmlldyQyMw:global_view/false" 1047 ncFakeConnector := &fakeConnector{ 1048 getObjectObj: NewNetworkContainer(NetworkContainer{NetviewName: netviewName, Cidr: cidr}), 1049 getObjectRef: "", 1050 resultObject: []NetworkContainer{*NewNetworkContainer(NetworkContainer{NetviewName: netviewName, Cidr: cidr, Ref: fakeRefReturn})}, 1051 } 1052 1053 objMgr := NewObjectManager(ncFakeConnector, cmpType, tenantID) 1054 1055 var actualNetworkContainer *NetworkContainer 1056 var err error 1057 It("should pass expected NetworkContainer Object to GetObject", func() { 1058 actualNetworkContainer, err = objMgr.GetNetworkContainer(netviewName, cidr) 1059 }) 1060 It("should return expected NetworkContainer Object", func() { 1061 Expect(*actualNetworkContainer).To(Equal(ncFakeConnector.resultObject.([]NetworkContainer)[0])) 1062 Expect(err).To(BeNil()) 1063 }) 1064 }) 1065 1066 Describe("Get Network", func() { 1067 cmpType := "Docker" 1068 tenantID := "01234567890abcdef01234567890abcdef" 1069 netviewName := "default_view" 1070 cidr := "28.0.42.0/24" 1071 networkName := "private-net" 1072 ea := EA{"Network Name": networkName} 1073 fakeRefReturn := fmt.Sprintf("network/ZG5zLm5ldHdvcmskODkuMC4wLjAvMjQvMjU:%s/%s", cidr, netviewName) 1074 nwFakeConnector := &fakeConnector{ 1075 getObjectObj: NewNetwork(Network{NetviewName: netviewName, Cidr: cidr}), 1076 getObjectRef: "", 1077 resultObject: []Network{*NewNetwork(Network{NetviewName: netviewName, Cidr: cidr, Ref: fakeRefReturn})}, 1078 } 1079 1080 nwFakeConnector.getObjectObj.(*Network).eaSearch = EASearch(ea) 1081 nwFakeConnector.resultObject.([]Network)[0].eaSearch = EASearch(ea) 1082 1083 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1084 1085 var actualNetwork *Network 1086 var err error 1087 It("should pass expected Network Object to GetObject", func() { 1088 actualNetwork, err = objMgr.GetNetwork(netviewName, cidr, ea) 1089 }) 1090 It("should return expected Network Object", func() { 1091 Expect(*actualNetwork).To(Equal(nwFakeConnector.resultObject.([]Network)[0])) 1092 Expect(err).To(BeNil()) 1093 }) 1094 }) 1095 1096 Describe("Get Network with Reference", func() { 1097 cmpType := "Docker" 1098 tenantID := "01234567890abcdef01234567890abcdef" 1099 cidr := "28.0.42.0/24" 1100 netviewName := "default_view" 1101 getRef := fmt.Sprintf("network/ZG5zLm5ldHdvcmskODkuMC4wLjAvMjQvMjU:%s/%s", cidr, netviewName) 1102 fakeRefReturn := getRef 1103 nwFakeConnector := &fakeConnector{ 1104 getObjectObj: NewNetwork(Network{}), 1105 getObjectRef: getRef, 1106 resultObject: []Network{*NewNetwork(Network{})}, 1107 fakeRefReturn: fakeRefReturn, 1108 } 1109 1110 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1111 1112 var actualRef *Network 1113 var err error 1114 It("should pass expected Network Ref to getObject", func() { 1115 actualRef, err = objMgr.GetNetworkwithref(fakeRefReturn) 1116 }) 1117 It("should return expected Network record Ref", func() { 1118 Expect(*actualRef).To(Equal(nwFakeConnector.resultObject.([]Network)[0])) 1119 Expect(err).To(BeNil()) 1120 }) 1121 }) 1122 1123 Describe("Get Fixed Address", func() { 1124 cmpType := "Docker" 1125 tenantID := "01234567890abcdef01234567890abcdef" 1126 netviewName := "private" 1127 cidr := "53.0.0.0/24" 1128 ipAddr := "53.0.0.21" 1129 macAddr := "01:23:45:67:80:ab" 1130 fakeRefReturn := fmt.Sprintf("fixedaddress/ZG5zLmJpbmRfY25h:%s/private", ipAddr) 1131 1132 fipFakeConnector := &fakeConnector{ 1133 getObjectObj: NewFixedAddress(FixedAddress{ 1134 NetviewName: netviewName, 1135 Cidr: cidr, 1136 IPAddress: ipAddr, 1137 Mac: macAddr, 1138 }), 1139 getObjectRef: "", 1140 resultObject: []FixedAddress{*NewFixedAddress(FixedAddress{ 1141 NetviewName: netviewName, 1142 Cidr: cidr, 1143 IPAddress: GetIPAddressFromRef(fakeRefReturn), 1144 Mac: macAddr, 1145 Ref: fakeRefReturn, 1146 })}, 1147 fakeRefReturn: fakeRefReturn, 1148 } 1149 1150 objMgr := NewObjectManager(fipFakeConnector, cmpType, tenantID) 1151 1152 var actualIP *FixedAddress 1153 var err error 1154 It("should pass expected Fixed Address Object to GetObject", func() { 1155 actualIP, err = objMgr.GetFixedAddress(netviewName, cidr, ipAddr, macAddr) 1156 }) 1157 It("should return expected Fixed Address Object", func() { 1158 Expect(*actualIP).To(Equal(fipFakeConnector.resultObject.([]FixedAddress)[0])) 1159 Expect(err).To(BeNil()) 1160 }) 1161 }) 1162 1163 Describe("Get Host Record Without DNS", func() { 1164 cmpType := "Docker" 1165 tenantID := "01234567890abcdef01234567890abcdef" 1166 hostName := "test" 1167 fakeRefReturn := fmt.Sprintf("record:host/ZG5zLmJpbmRfY25h:%s/%20%20", hostName) 1168 fipFakeConnector := &fakeConnector{ 1169 getObjectObj: NewHostRecord(HostRecord{ 1170 Name: hostName, 1171 }), 1172 getObjectRef: "", 1173 resultObject: []HostRecord{*NewHostRecord(HostRecord{ 1174 Name: hostName, 1175 Ref: fakeRefReturn, 1176 })}, 1177 fakeRefReturn: fakeRefReturn, 1178 } 1179 1180 objMgr := NewObjectManager(fipFakeConnector, cmpType, tenantID) 1181 1182 var actualhostRecord *HostRecord 1183 var err error 1184 It("should pass expected Host record Object to GetObject", func() { 1185 actualhostRecord, err = objMgr.GetHostRecord(hostName) 1186 }) 1187 It("should return expected Host record Object", func() { 1188 Expect(*actualhostRecord).To(Equal(fipFakeConnector.resultObject.([]HostRecord)[0])) 1189 Expect(err).To(BeNil()) 1190 }) 1191 1192 }) 1193 1194 Describe("Get EA Definition", func() { 1195 cmpType := "Docker" 1196 tenantID := "01234567890abcdef01234567890abcdef" 1197 comment := "Test Extensible Attribute" 1198 flags := "CGV" 1199 listValues := []EADefListValue{"True", "False"} 1200 name := "TestEA" 1201 eaType := "string" 1202 allowedTypes := []string{"arecord", "aaarecord", "ptrrecord"} 1203 ead := EADefinition{ 1204 Name: name, 1205 } 1206 fakeRefReturn := "extensibleattributedef/ZG5zLm5ldHdvcmtfdmlldyQyMw:TestEA" 1207 eadRes := EADefinition{ 1208 Name: name, 1209 Comment: comment, 1210 Flags: flags, 1211 ListValues: listValues, 1212 Type: eaType, 1213 AllowedObjectTypes: allowedTypes, 1214 Ref: fakeRefReturn, 1215 } 1216 1217 eadFakeConnector := &fakeConnector{ 1218 getObjectObj: NewEADefinition(ead), 1219 getObjectRef: "", 1220 resultObject: []EADefinition{*NewEADefinition(eadRes)}, 1221 fakeRefReturn: fakeRefReturn, 1222 } 1223 1224 objMgr := NewObjectManager(eadFakeConnector, cmpType, tenantID) 1225 1226 var actualEADef *EADefinition 1227 var err error 1228 It("should pass expected EA Definintion Object to GetObject", func() { 1229 actualEADef, err = objMgr.GetEADefinition(name) 1230 }) 1231 It("should return expected EA Definition Object", func() { 1232 Expect(*actualEADef).To(Equal(eadFakeConnector.resultObject.([]EADefinition)[0])) 1233 Expect(err).To(BeNil()) 1234 }) 1235 }) 1236 1237 Describe("Delete Network", func() { 1238 cmpType := "Docker" 1239 tenantID := "01234567890abcdef01234567890abcdef" 1240 netviewName := "default_view" 1241 cidr := "28.0.42.0/24" 1242 deleteRef := fmt.Sprintf("network/ZG5zLm5ldHdvcmskODkuMC4wLjAvMjQvMjU:%s/%s", cidr, netviewName) 1243 fakeRefReturn := deleteRef 1244 nwFakeConnector := &fakeConnector{ 1245 deleteObjectRef: deleteRef, 1246 fakeRefReturn: fakeRefReturn, 1247 } 1248 1249 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1250 1251 var actualRef string 1252 var err error 1253 It("should pass expected Network Ref to DeleteObject", func() { 1254 actualRef, err = objMgr.DeleteNetwork(deleteRef, netviewName) 1255 }) 1256 It("should return expected Network Ref", func() { 1257 Expect(actualRef).To(Equal(fakeRefReturn)) 1258 Expect(err).To(BeNil()) 1259 }) 1260 }) 1261 1262 Describe("Delete Network View", func() { 1263 cmpType := "Docker" 1264 tenantID := "01234567890abcdef01234567890abcdef" 1265 fakeRefReturn := "networkview/ZG5zLm5ldHdvcmtfdmlldyQyMw:global_view/false" 1266 deleteRef := fakeRefReturn 1267 nwFakeConnector := &fakeConnector{ 1268 deleteObjectRef: deleteRef, 1269 fakeRefReturn: fakeRefReturn, 1270 } 1271 1272 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1273 1274 var actualRef string 1275 var err error 1276 It("should pass expected Network View Ref to DeleteObject", func() { 1277 actualRef, err = objMgr.DeleteNetworkView(deleteRef) 1278 }) 1279 It("should return expected Network View Ref", func() { 1280 Expect(actualRef).To(Equal(fakeRefReturn)) 1281 Expect(err).To(BeNil()) 1282 }) 1283 }) 1284 1285 Describe("Delete Fixed Address", func() { 1286 cmpType := "Docker" 1287 tenantID := "01234567890abcdef01234567890abcdef" 1288 netviewName := "private" 1289 cidr := "83.0.101.0/24" 1290 ipAddr := "83.0.101.68" 1291 macAddr := "01:23:45:67:80:ab" 1292 fakeRefReturn := fmt.Sprintf("fixedaddress/ZG5zLmJpbmRfY25h:%s/private", ipAddr) 1293 1294 fipFakeConnector := &fakeConnector{ 1295 getObjectObj: NewFixedAddress(FixedAddress{ 1296 NetviewName: netviewName, 1297 Cidr: cidr, 1298 IPAddress: ipAddr, 1299 Mac: macAddr, 1300 }), 1301 getObjectRef: "", 1302 resultObject: []FixedAddress{*NewFixedAddress(FixedAddress{ 1303 NetviewName: netviewName, 1304 Cidr: cidr, 1305 IPAddress: GetIPAddressFromRef(fakeRefReturn), 1306 Mac: macAddr, 1307 Ref: fakeRefReturn, 1308 })}, 1309 deleteObjectRef: fakeRefReturn, 1310 fakeRefReturn: fakeRefReturn, 1311 } 1312 1313 objMgr := NewObjectManager(fipFakeConnector, cmpType, tenantID) 1314 1315 var actualRef string 1316 var err error 1317 It("should pass expected Fixed Address Object to GetObject and DeleteObject", func() { 1318 actualRef, err = objMgr.ReleaseIP(netviewName, cidr, ipAddr, macAddr) 1319 }) 1320 It("should return expected Fixed Address Ref", func() { 1321 Expect(actualRef).To(Equal(fakeRefReturn)) 1322 Expect(err).To(BeNil()) 1323 }) 1324 }) 1325 1326 Describe("Delete Host Record", func() { 1327 cmpType := "Docker" 1328 tenantID := "01234567890abcdef01234567890abcdef" 1329 hostName := "test" 1330 deleteRef := fmt.Sprintf("record:host/ZG5zLmJpbmRfY25h:%s/%20%20", hostName) 1331 fakeRefReturn := deleteRef 1332 nwFakeConnector := &fakeConnector{ 1333 deleteObjectRef: deleteRef, 1334 fakeRefReturn: fakeRefReturn, 1335 } 1336 1337 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1338 1339 var actualRef string 1340 var err error 1341 It("should pass expected Host record Ref to DeleteObject", func() { 1342 actualRef, err = objMgr.DeleteHostRecord(deleteRef) 1343 }) 1344 It("should return expected Host record Ref", func() { 1345 Expect(actualRef).To(Equal(fakeRefReturn)) 1346 Expect(err).To(BeNil()) 1347 }) 1348 }) 1349 1350 Describe("Delete A Record", func() { 1351 cmpType := "Docker" 1352 tenantID := "01234567890abcdef01234567890abcdef" 1353 recordName := "test" 1354 deleteRef := fmt.Sprintf("record:a/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 1355 fakeRefReturn := deleteRef 1356 nwFakeConnector := &fakeConnector{ 1357 deleteObjectRef: deleteRef, 1358 fakeRefReturn: fakeRefReturn, 1359 } 1360 1361 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1362 1363 var actualRef string 1364 var err error 1365 It("should pass expected A record Ref to DeleteObject", func() { 1366 actualRef, err = objMgr.DeleteARecord(deleteRef) 1367 }) 1368 It("should return expected A record Ref", func() { 1369 Expect(actualRef).To(Equal(fakeRefReturn)) 1370 Expect(err).To(BeNil()) 1371 }) 1372 }) 1373 1374 Describe("Delete PTR Record", func() { 1375 cmpType := "Docker" 1376 tenantID := "01234567890abcdef01234567890abcdef" 1377 recordName := "test" 1378 deleteRef := fmt.Sprintf("record:ptr/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 1379 fakeRefReturn := deleteRef 1380 nwFakeConnector := &fakeConnector{ 1381 deleteObjectRef: deleteRef, 1382 fakeRefReturn: fakeRefReturn, 1383 } 1384 1385 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1386 1387 var actualRef string 1388 var err error 1389 It("should pass expected PTR record Ref to DeleteObject", func() { 1390 actualRef, err = objMgr.DeletePTRRecord(deleteRef) 1391 }) 1392 It("should return expected PTR record Ref", func() { 1393 Expect(actualRef).To(Equal(fakeRefReturn)) 1394 Expect(err).To(BeNil()) 1395 }) 1396 }) 1397 1398 Describe("Delete CNAME Record", func() { 1399 cmpType := "Docker" 1400 tenantID := "01234567890abcdef01234567890abcdef" 1401 recordName := "test" 1402 deleteRef := fmt.Sprintf("record:CNAME/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 1403 fakeRefReturn := deleteRef 1404 nwFakeConnector := &fakeConnector{ 1405 deleteObjectRef: deleteRef, 1406 fakeRefReturn: fakeRefReturn, 1407 } 1408 1409 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1410 1411 var actualRef string 1412 var err error 1413 It("should pass expected CNAME record Ref to DeleteObject", func() { 1414 actualRef, err = objMgr.DeleteCNAMERecord(deleteRef) 1415 }) 1416 It("should return expected CNAME record Ref", func() { 1417 Expect(actualRef).To(Equal(fakeRefReturn)) 1418 Expect(err).To(BeNil()) 1419 }) 1420 }) 1421 1422 Describe("Delete TXT Record", func() { 1423 cmpType := "Docker" 1424 tenantID := "01234567890abcdef01234567890abcdef" 1425 recordName := "test" 1426 deleteRef := fmt.Sprintf("record:txt/ZG5zLmJpbmRfY25h:%s/%20%20", recordName) 1427 fakeRefReturn := deleteRef 1428 nwFakeConnector := &fakeConnector{ 1429 deleteObjectRef: deleteRef, 1430 fakeRefReturn: fakeRefReturn, 1431 } 1432 1433 objMgr := NewObjectManager(nwFakeConnector, cmpType, tenantID) 1434 1435 var actualRef string 1436 var err error 1437 It("should pass expected TXT record Ref to DeleteObject", func() { 1438 actualRef, err = objMgr.DeleteTXTRecord(deleteRef) 1439 }) 1440 It("should return expected TXT record Ref", func() { 1441 Expect(actualRef).To(Equal(fakeRefReturn)) 1442 Expect(err).To(BeNil()) 1443 }) 1444 }) 1445 1446 Describe("BuildNetworkViewFromRef", func() { 1447 netviewName := "default_view" 1448 netviewRef := fmt.Sprintf("networkview/ZG5zLm5ldHdvcmtfdmlldyQyMw:%s/false", netviewName) 1449 1450 expectedNetworkView := NetworkView{Ref: netviewRef, Name: netviewName} 1451 It("should return expected Network View Object", func() { 1452 Expect(*BuildNetworkViewFromRef(netviewRef)).To(Equal(expectedNetworkView)) 1453 }) 1454 It("should failed if bad Network View Ref is provided", func() { 1455 Expect(BuildNetworkViewFromRef("bad")).To(BeNil()) 1456 }) 1457 }) 1458 1459 Describe("BuildNetworkFromRef", func() { 1460 netviewName := "test_view" 1461 cidr := "23.11.0.0/24" 1462 networkRef := fmt.Sprintf("network/ZG5zLm5ldHdvcmtfdmlldyQyMw:%s/%s", cidr, netviewName) 1463 1464 expectedNetwork := Network{Ref: networkRef, NetviewName: netviewName, Cidr: cidr} 1465 It("should return expected Network Object", func() { 1466 Expect(*BuildNetworkFromRef(networkRef)).To(Equal(expectedNetwork)) 1467 }) 1468 It("should failed if bad Network Ref is provided", func() { 1469 Expect(BuildNetworkFromRef("network/ZG5zLm5ldHdvcmtfdmlldyQyMw")).To(BeNil()) 1470 }) 1471 }) 1472 1473 Describe("Get Capacity report", func() { 1474 cmpType := "Heka" 1475 tenantID := "0123" 1476 var name string = "Member1" 1477 fakeRefReturn := fmt.Sprintf("member/ZG5zLmJpbmRfY25h:/%s", name) 1478 1479 fakeConnector := &fakeConnector{ 1480 getObjectObj: NewCapcityReport(CapacityReport{Name: name}), 1481 getObjectRef: "", 1482 resultObject: []CapacityReport{*NewCapcityReport(CapacityReport{ 1483 Ref: fakeRefReturn, 1484 Name: name, 1485 })}, 1486 fakeRefReturn: fakeRefReturn, 1487 } 1488 1489 objMgr := NewObjectManager(fakeConnector, cmpType, tenantID) 1490 1491 var actualReport []CapacityReport 1492 var err error 1493 1494 It("should pass expected Capacityreport object to GetObject", func() { 1495 actualReport, err = objMgr.GetCapacityReport(name) 1496 }) 1497 It("should return expected CapacityReport Object", func() { 1498 Expect(actualReport[0]).To(Equal(fakeConnector.resultObject.([]CapacityReport)[0])) 1499 Expect(err).To(BeNil()) 1500 }) 1501 }) 1502 1503 Describe("Get upgrade status", func() { 1504 cmpType := "Heka" 1505 tenantID := "0123" 1506 var StatusType string = "GRID" 1507 fakeRefReturn := fmt.Sprintf("upgradestatus/Li51cGdyYWRlc3RhdHVzJHVwZ3JhZGVfc3RhdHVz:test") 1508 1509 USFakeConnector := &fakeConnector{ 1510 getObjectObj: NewUpgradeStatus(UpgradeStatus{Type: StatusType}), 1511 getObjectRef: "", 1512 resultObject: []UpgradeStatus{*NewUpgradeStatus(UpgradeStatus{ 1513 Ref: fakeRefReturn, 1514 Type: StatusType, 1515 })}, 1516 fakeRefReturn: fakeRefReturn, 1517 } 1518 1519 objMgr := NewObjectManager(USFakeConnector, cmpType, tenantID) 1520 1521 var actualStatus []UpgradeStatus 1522 var err error 1523 1524 It("should pass expected upgradestatus object to GetObject", func() { 1525 actualStatus, err = objMgr.GetUpgradeStatus(StatusType) 1526 }) 1527 It("should return expected upgradestatus Object", func() { 1528 Expect(actualStatus[0]).To(Equal(USFakeConnector.resultObject.([]UpgradeStatus)[0])) 1529 Expect(err).To(BeNil()) 1530 }) 1531 1532 }) 1533 Describe("Get upgrade status Error case", func() { 1534 cmpType := "Heka" 1535 tenantID := "0123" 1536 StatusType := "" 1537 fakeRefReturn := fmt.Sprintf("upgradestatus/Li51cGdyYWRlc3RhdHVzJHVwZ3JhZGVfc3RhdHVz:test") 1538 expectErr := errors.New("Status type can not be nil") 1539 USFakeConnector := &fakeConnector{ 1540 getObjectObj: NewUpgradeStatus(UpgradeStatus{Type: StatusType}), 1541 getObjectRef: "", 1542 resultObject: []UpgradeStatus{*NewUpgradeStatus(UpgradeStatus{ 1543 Ref: fakeRefReturn, 1544 Type: StatusType, 1545 })}, 1546 fakeRefReturn: fakeRefReturn, 1547 } 1548 objMgr := NewObjectManager(USFakeConnector, cmpType, tenantID) 1549 It("upgradestatus object to GetObject", func() { 1550 _, err := objMgr.GetUpgradeStatus(StatusType) 1551 Expect(err).To(Equal(expectErr)) 1552 }) 1553 1554 }) 1555 Describe("GetAllMembers", func() { 1556 cmpType := "Heka" 1557 tenantID := "0123" 1558 var err error 1559 fakeRefReturn := fmt.Sprintf("member/Li51cGdyYWRlc3RhdHVzJHVwZ3JhZGVfc3RhdHVz:test") 1560 returnFields := []string{"host_name", "node_info", "time_zone"} 1561 MemFakeConnector := &fakeConnector{ 1562 getObjectObj: NewMember(Member{}), 1563 getObjectRef: "", 1564 resultObject: []Member{*NewMember(Member{ 1565 Ref: fakeRefReturn, 1566 })}, 1567 fakeRefReturn: fakeRefReturn, 1568 } 1569 objMgr := NewObjectManager(MemFakeConnector, cmpType, tenantID) 1570 var actualMembers []Member 1571 It("should return expected member Object", func() { 1572 actualMembers, err = objMgr.GetAllMembers() 1573 Expect(actualMembers[0]).To(Equal(MemFakeConnector.resultObject.([]Member)[0])) 1574 Expect(actualMembers[0].returnFields).To(Equal(returnFields)) 1575 Expect(err).To(BeNil()) 1576 }) 1577 }) 1578 1579 Describe("GetGridInfo", func() { 1580 cmpType := "Heka" 1581 tenantID := "0123" 1582 var err error 1583 fakeRefReturn := fmt.Sprintf("grid/Li511cGdyYWRlc3RhdHVzJHVwZ3JhZGVfc3RhdHVz:test") 1584 returnFields := []string{"name", "ntp_setting"} 1585 GridFakeConnector := &fakeConnector{ 1586 getObjectObj: NewGrid(Grid{}), 1587 getObjectRef: "", 1588 resultObject: []Grid{*NewGrid(Grid{ 1589 Ref: fakeRefReturn, 1590 })}, 1591 fakeRefReturn: fakeRefReturn, 1592 } 1593 objMgr := NewObjectManager(GridFakeConnector, cmpType, tenantID) 1594 var actualGridInfo []Grid 1595 It("should return expected Grid Object", func() { 1596 actualGridInfo, err = objMgr.GetGridInfo() 1597 Expect(actualGridInfo[0]).To(Equal(GridFakeConnector.resultObject.([]Grid)[0])) 1598 Expect(actualGridInfo[0].returnFields).To(Equal(returnFields)) 1599 Expect(err).To(BeNil()) 1600 }) 1601 }) 1602 1603 Describe("GetGridLicense", func() { 1604 cmpType := "Heka" 1605 tenantID := "0123" 1606 var err error 1607 fakeRefReturn := fmt.Sprintf("license/Li511cGdyYWRlc3RhdHVzJHVwZ3JhZGVfc3RhdHVz:test") 1608 returnFields := []string{"expiration_status", 1609 "expiry_date", 1610 "key", 1611 "limit", 1612 "limit_context", 1613 "type"} 1614 LicFakeConnector := &fakeConnector{ 1615 getObjectObj: NewGridLicense(License{}), 1616 getObjectRef: "", 1617 resultObject: []License{*NewGridLicense(License{ 1618 Ref: fakeRefReturn, 1619 })}, 1620 fakeRefReturn: fakeRefReturn, 1621 } 1622 objMgr := NewObjectManager(LicFakeConnector, cmpType, tenantID) 1623 var actualGridLicense []License 1624 It("should return expected License Object", func() { 1625 actualGridLicense, err = objMgr.GetGridLicense() 1626 Expect(actualGridLicense[0]).To(Equal(LicFakeConnector.resultObject.([]License)[0])) 1627 Expect(actualGridLicense[0].returnFields).To(Equal(returnFields)) 1628 Expect(err).To(BeNil()) 1629 }) 1630 }) 1631 1632 Describe("Create Zone Auth", func() { 1633 cmpType := "Docker" 1634 tenantID := "01234567890abcdef01234567890abcdef" 1635 fqdn := "azone.example.com" 1636 fakeRefReturn := "zone_auth/ZG5zLnpvbmUkLl9kZWZhdWx0LnphLmNvLmFic2EuY2Fhcy5vaG15Z2xiLmdzbGJpYmNsaWVudA:dzone.example.com/default" 1637 zaFakeConnector := &fakeConnector{ 1638 createObjectObj: NewZoneAuth(ZoneAuth{Fqdn: fqdn}), 1639 resultObject: NewZoneAuth(ZoneAuth{Fqdn: fqdn, Ref: fakeRefReturn}), 1640 fakeRefReturn: fakeRefReturn, 1641 } 1642 1643 objMgr := NewObjectManager(zaFakeConnector, cmpType, tenantID) 1644 1645 ea := objMgr.getBasicEA(true) 1646 1647 zaFakeConnector.createObjectObj.(*ZoneAuth).Ea = ea 1648 zaFakeConnector.createObjectObj.(*ZoneAuth).Ea["Tenant ID"] = tenantID 1649 zaFakeConnector.createObjectObj.(*ZoneAuth).Ea["CMP Type"] = cmpType 1650 1651 zaFakeConnector.resultObject.(*ZoneAuth).Ea = ea 1652 zaFakeConnector.resultObject.(*ZoneAuth).Ea["Tenant ID"] = tenantID 1653 zaFakeConnector.resultObject.(*ZoneAuth).Ea["CMP Type"] = cmpType 1654 1655 var actualZoneAuth *ZoneAuth 1656 var err error 1657 It("should pass expected ZoneAuth Object to CreateObject", func() { 1658 actualZoneAuth, err = objMgr.CreateZoneAuth(fqdn, ea) 1659 }) 1660 It("should return expected ZoneAuth Object", func() { 1661 Expect(actualZoneAuth).To(Equal(zaFakeConnector.resultObject)) 1662 Expect(err).To(BeNil()) 1663 }) 1664 }) 1665 1666 Describe("Get AuthZone by ref", func() { 1667 cmpType := "Docker" 1668 tenantID := "01234567890abcdef01234567890abcdef" 1669 fqdn := "azone.example.com" 1670 fakeRefReturn := "zone_delegated/ZG5zLnpvbmUkLl9kZWZhdWx0LnphLmNvLmFic2EuY2Fhcy5vaG15Z2xiLmdzbGJpYmNsaWVudA:azone.example.com/default" 1671 zdFakeConnector := &fakeConnector{ 1672 getObjectObj: NewZoneAuth(ZoneAuth{}), 1673 getObjectRef: fakeRefReturn, 1674 resultObject: *NewZoneAuth(ZoneAuth{Fqdn: fqdn}), 1675 } 1676 1677 objMgr := NewObjectManager(zdFakeConnector, cmpType, tenantID) 1678 1679 var actualZoneAuth ZoneAuth 1680 var err error 1681 It("should pass expected ZoneAuth Object to GetObject", func() { 1682 actualZoneAuth, err = objMgr.GetZoneAuthByRef(fakeRefReturn) 1683 }) 1684 fmt.Printf("doodo %s",actualZoneAuth) 1685 It("should return expected ZoneAuth Object", func() { 1686 Expect(actualZoneAuth).To(Equal(zdFakeConnector.resultObject)) 1687 Expect(err).To(BeNil()) 1688 }) 1689 It("should return empty ZoneAuth and nil error if ref is empty", func() { 1690 zdFakeConnector.getObjectObj.(*ZoneAuth).IBBase.objectType = "" 1691 zdFakeConnector.getObjectObj.(*ZoneAuth).IBBase.returnFields = nil 1692 actualZoneAuth, err = objMgr.GetZoneAuthByRef("") 1693 Expect(actualZoneAuth).To(Equal(*zdFakeConnector.getObjectObj.(*ZoneAuth))) 1694 Expect(err).To(BeNil()) 1695 }) 1696 }) 1697 1698 Describe("Delete ZoneAuth", func() { 1699 cmpType := "Docker" 1700 tenantID := "01234567890abcdef01234567890abcdef" 1701 deleteRef := "zone_auth/ZG5zLnpvbmUkLl9kZWZhdWx0LnphLmNvLmFic2EuY2Fhcy5vaG15Z2xiLmdzbGJpYmNsaWVudA:dzone.example.com/default" 1702 fakeRefReturn := deleteRef 1703 zaFakeConnector := &fakeConnector{ 1704 deleteObjectRef: deleteRef, 1705 fakeRefReturn: fakeRefReturn, 1706 } 1707 1708 objMgr := NewObjectManager(zaFakeConnector, cmpType, tenantID) 1709 1710 var actualRef string 1711 var err error 1712 It("should pass expected ZoneAuth Ref to DeleteObject", func() { 1713 actualRef, err = objMgr.DeleteZoneAuth(deleteRef) 1714 }) 1715 It("should return expected ZoneAuth Ref", func() { 1716 Expect(actualRef).To(Equal(fakeRefReturn)) 1717 Expect(err).To(BeNil()) 1718 }) 1719 }) 1720 1721 Describe("Get Zone Delegated", func() { 1722 cmpType := "Docker" 1723 tenantID := "01234567890abcdef01234567890abcdef" 1724 fqdn := "dzone.example.com" 1725 fakeRefReturn := "zone_delegated/ZG5zLnpvbmUkLl9kZWZhdWx0LnphLmNvLmFic2EuY2Fhcy5vaG15Z2xiLmdzbGJpYmNsaWVudA:dzone.example.com/default" 1726 zdFakeConnector := &fakeConnector{ 1727 getObjectObj: NewZoneDelegated(ZoneDelegated{Fqdn: fqdn}), 1728 getObjectRef: "", 1729 resultObject: []ZoneDelegated{*NewZoneDelegated(ZoneDelegated{Fqdn: fqdn, Ref: fakeRefReturn})}, 1730 } 1731 1732 objMgr := NewObjectManager(zdFakeConnector, cmpType, tenantID) 1733 1734 var actualZoneDelegated *ZoneDelegated 1735 var err error 1736 It("should pass expected ZoneDelegated Object to GetObject", func() { 1737 actualZoneDelegated, err = objMgr.GetZoneDelegated(fqdn) 1738 }) 1739 It("should return expected ZoneDelegated Object", func() { 1740 Expect(*actualZoneDelegated).To(Equal(zdFakeConnector.resultObject.([]ZoneDelegated)[0])) 1741 Expect(err).To(BeNil()) 1742 }) 1743 It("should return nil if fqdn is empty", func() { 1744 zdFakeConnector.getObjectObj.(*ZoneDelegated).Fqdn = "" 1745 actualZoneDelegated, err = objMgr.GetZoneDelegated("") 1746 Expect(actualZoneDelegated).To(BeNil()) 1747 Expect(err).To(BeNil()) 1748 }) 1749 }) 1750 1751 Describe("Create Zone Delegated", func() { 1752 cmpType := "Docker" 1753 tenantID := "01234567890abcdef01234567890abcdef" 1754 fqdn := "dzone.example.com" 1755 delegateTo := []NameServer{ 1756 {Address: "10.0.0.1", Name: "test1.dzone.example.com"}, 1757 {Address: "10.0.0.2", Name: "test2.dzone.example.com"}} 1758 fakeRefReturn := "zone_delegated/ZG5zLnpvbmUkLl9kZWZhdWx0LnphLmNvLmFic2EuY2Fhcy5vaG15Z2xiLmdzbGJpYmNsaWVudA:dzone.example.com/default" 1759 zdFakeConnector := &fakeConnector{ 1760 createObjectObj: NewZoneDelegated(ZoneDelegated{Fqdn: fqdn, DelegateTo: delegateTo}), 1761 resultObject: NewZoneDelegated(ZoneDelegated{Fqdn: fqdn, DelegateTo: delegateTo, Ref: fakeRefReturn}), 1762 fakeRefReturn: fakeRefReturn, 1763 } 1764 1765 objMgr := NewObjectManager(zdFakeConnector, cmpType, tenantID) 1766 1767 var actualZoneDelegated *ZoneDelegated 1768 var err error 1769 It("should pass expected ZoneDelegated Object to CreateObject", func() { 1770 actualZoneDelegated, err = objMgr.CreateZoneDelegated(fqdn, delegateTo) 1771 }) 1772 It("should return expected ZoneDelegated Object", func() { 1773 Expect(actualZoneDelegated).To(Equal(zdFakeConnector.resultObject)) 1774 Expect(err).To(BeNil()) 1775 }) 1776 }) 1777 1778 Describe("Update Zone Delegated", func() { 1779 cmpType := "Docker" 1780 tenantID := "01234567890abcdef01234567890abcdef" 1781 fakeRefReturn := "zone_delegated/ZG5zLnpvbmUkLl9kZWZhdWx0LnphLmNvLmFic2EuY2Fhcy5vaG15Z2xiLmdzbGJpYmNsaWVudA:dzone.example.com/default" 1782 delegateTo := []NameServer{ 1783 {Address: "10.0.0.1", Name: "test1.dzone.example.com"}, 1784 {Address: "10.0.0.2", Name: "test2.dzone.example.com"}} 1785 1786 receiveUpdateObject := NewZoneDelegated(ZoneDelegated{Ref: fakeRefReturn, DelegateTo: delegateTo}) 1787 returnUpdateObject := NewZoneDelegated(ZoneDelegated{DelegateTo: delegateTo, Ref: fakeRefReturn}) 1788 zdFakeConnector := &fakeConnector{ 1789 fakeRefReturn: fakeRefReturn, 1790 resultObject: returnUpdateObject, 1791 updateObjectObj: receiveUpdateObject, 1792 updateObjectRef: fakeRefReturn, 1793 } 1794 1795 objMgr := NewObjectManager(zdFakeConnector, cmpType, tenantID) 1796 1797 var updatedObject *ZoneDelegated 1798 var err error 1799 It("should pass expected updated object to UpdateObject", func() { 1800 updatedObject, err = objMgr.UpdateZoneDelegated(fakeRefReturn, delegateTo) 1801 }) 1802 It("should update zone with new delegation server list with no error", func() { 1803 Expect(updatedObject).To(Equal(returnUpdateObject)) 1804 Expect(err).To(BeNil()) 1805 }) 1806 }) 1807 1808 Describe("Delete ZoneDelegated", func() { 1809 cmpType := "Docker" 1810 tenantID := "01234567890abcdef01234567890abcdef" 1811 deleteRef := "zone_delegated/ZG5zLnpvbmUkLl9kZWZhdWx0LnphLmNvLmFic2EuY2Fhcy5vaG15Z2xiLmdzbGJpYmNsaWVudA:dzone.example.com/default" 1812 fakeRefReturn := deleteRef 1813 zdFakeConnector := &fakeConnector{ 1814 deleteObjectRef: deleteRef, 1815 fakeRefReturn: fakeRefReturn, 1816 } 1817 1818 objMgr := NewObjectManager(zdFakeConnector, cmpType, tenantID) 1819 1820 var actualRef string 1821 var err error 1822 It("should pass expected ZoneDelegated Ref to DeleteObject", func() { 1823 actualRef, err = objMgr.DeleteZoneDelegated(deleteRef) 1824 }) 1825 It("should return expected ZoneDelegated Ref", func() { 1826 Expect(actualRef).To(Equal(fakeRefReturn)) 1827 Expect(err).To(BeNil()) 1828 }) 1829 }) 1830 1831 Describe("Omit cloud attributes", func() { 1832 connector := &fakeConnector{} 1833 objMgr := NewObjectManager(connector, "", "") 1834 objMgr.OmitCloudAttrs = true 1835 1836 ea := objMgr.getBasicEA(true) 1837 It("should return empty EA", func() { 1838 Expect(len(ea)).To(Equal(0)) 1839 }) 1840 }) 1841 })