← Back to branch summary

~wallyworld/goose/rate-limit-retry-tests

« back to all changes in this revision

Viewing changes to testservices/novaservice/service_http_test.go

nova double: list server filters and run server.

Implemented filters by status and name (others not implemented, but
probably also not needed), as well as creating a server (RunServer).

Added a few needed things: serverByName and generateUUID + tests.

With this, the nova double will be up-to-date with the nova client
and functional.

R=fwereade, rog
CC=
https://codereview.appspot.com/7073060

Show diffs side-by-side

added added

removed removed

Lines of Context:
testservices/novaservice/service_http_test.go
474
474
        assertJSON(c, resp, &expected)
475
475
        c.Assert(expected.Flavors, HasLen, 0)
476
476
        flavors := []nova.FlavorDetail{
477
 
                nova.FlavorDetail{Id: "fl1", Name: "flavor 1"},
478
 
                nova.FlavorDetail{Id: "fl2", Name: "flavor 2"},
 
477
                {Id: "fl1", Name: "flavor 1"},
 
478
                {Id: "fl2", Name: "flavor 2"},
479
479
        }
480
480
        for i, flavor := range flavors {
481
481
                s.service.buildFlavorLinks(&flavor)
482
482
                flavors[i] = flavor
483
483
                err := s.service.addFlavor(flavor)
 
484
                c.Assert(err, IsNil)
484
485
                defer s.service.removeFlavor(flavor.Id)
485
 
                c.Assert(err, IsNil)
486
486
        }
487
487
        entities = s.service.allFlavorsAsEntities()
488
488
        resp, err = s.authRequest("GET", "/flavors", nil, nil)
515
515
        assertJSON(c, resp, &expected)
516
516
        c.Assert(expected.Flavors, HasLen, 0)
517
517
        flavors = []nova.FlavorDetail{
518
 
                nova.FlavorDetail{Id: "fl1", Name: "flavor 1"},
519
 
                nova.FlavorDetail{Id: "fl2", Name: "flavor 2"},
 
518
                {Id: "fl1", Name: "flavor 1"},
 
519
                {Id: "fl2", Name: "flavor 2"},
520
520
        }
521
521
        for i, flavor := range flavors {
522
522
                s.service.buildFlavorLinks(&flavor)
539
539
}
540
540
 
541
541
func (s *NovaHTTPSuite) TestGetServers(c *C) {
542
 
        entities := s.service.allServersAsEntities()
 
542
        entities := s.service.allServersAsEntities(nil)
543
543
        c.Assert(entities, HasLen, 0)
544
544
        var expected struct {
545
545
                Servers []nova.Entity
550
550
        assertJSON(c, resp, &expected)
551
551
        c.Assert(expected.Servers, HasLen, 0)
552
552
        servers := []nova.ServerDetail{
553
 
                nova.ServerDetail{Id: "sr1", Name: "server 1"},
554
 
                nova.ServerDetail{Id: "sr2", Name: "server 2"},
 
553
                {Id: "sr1", Name: "server 1"},
 
554
                {Id: "sr2", Name: "server 2"},
555
555
        }
556
556
        for i, server := range servers {
557
557
                s.service.buildServerLinks(&server)
558
558
                servers[i] = server
559
559
                err := s.service.addServer(server)
 
560
                c.Assert(err, IsNil)
560
561
                defer s.service.removeServer(server.Id)
561
 
                c.Assert(err, IsNil)
562
562
        }
563
 
        entities = s.service.allServersAsEntities()
 
563
        entities = s.service.allServersAsEntities(nil)
564
564
        resp, err = s.authRequest("GET", "/servers", nil, nil)
565
565
        c.Assert(err, IsNil)
566
566
        c.Assert(resp.StatusCode, Equals, http.StatusOK)
567
567
        assertJSON(c, resp, &expected)
 
568
        c.Assert(expected.Servers, HasLen, 2)
568
569
        if expected.Servers[0].Id != entities[0].Id {
569
570
                expected.Servers[0], expected.Servers[1] = expected.Servers[1], expected.Servers[0]
570
571
        }
579
580
        c.Assert(expectedServer.Server, DeepEquals, servers[0])
580
581
}
581
582
 
 
583
func (s *NovaHTTPSuite) TestGetServersWithFilters(c *C) {
 
584
        entities := s.service.allServersAsEntities(nil)
 
585
        c.Assert(entities, HasLen, 0)
 
586
        var expected struct {
 
587
                Servers []nova.Entity
 
588
        }
 
589
        url := "/servers?status=RESCUE&status=BUILD&name=srv1&name=srv2"
 
590
        resp, err := s.authRequest("GET", url, nil, nil)
 
591
        c.Assert(err, IsNil)
 
592
        c.Assert(resp.StatusCode, Equals, http.StatusOK)
 
593
        assertJSON(c, resp, &expected)
 
594
        c.Assert(expected.Servers, HasLen, 0)
 
595
        servers := []nova.ServerDetail{
 
596
                {Id: "sr1", Name: "srv1", Status: nova.StatusBuild},
 
597
                {Id: "sr2", Name: "srv2", Status: nova.StatusRescue},
 
598
                {Id: "sr3", Name: "srv3", Status: nova.StatusActive},
 
599
        }
 
600
        for i, server := range servers {
 
601
                s.service.buildServerLinks(&server)
 
602
                servers[i] = server
 
603
                err := s.service.addServer(server)
 
604
                c.Assert(err, IsNil)
 
605
                defer s.service.removeServer(server.Id)
 
606
        }
 
607
        filter := nova.NewFilter()
 
608
        filter.Add(nova.FilterStatus, nova.StatusRescue)
 
609
        filter.Add(nova.FilterStatus, nova.StatusBuild)
 
610
        filter.Add(nova.FilterServer, "srv1")
 
611
        filter.Add(nova.FilterServer, "srv2")
 
612
        entities = s.service.allServersAsEntities(filter)
 
613
        resp, err = s.authRequest("GET", url, nil, nil)
 
614
        c.Assert(err, IsNil)
 
615
        c.Assert(resp.StatusCode, Equals, http.StatusOK)
 
616
        assertJSON(c, resp, &expected)
 
617
        if expected.Servers[0].Id != entities[0].Id {
 
618
                expected.Servers[0], expected.Servers[1] = expected.Servers[1], expected.Servers[0]
 
619
        }
 
620
        c.Assert(expected.Servers, DeepEquals, entities[:2])
 
621
}
 
622
 
 
623
func (s *NovaHTTPSuite) TestNewUUID(c *C) {
 
624
        uuid, err := newUUID()
 
625
        c.Assert(err, IsNil)
 
626
        var p1, p2, p3, p4, p5 string
 
627
        num, err := fmt.Sscanf(uuid, "%8x-%4x-%4x-%4x-%12x", &p1, &p2, &p3, &p4, &p5)
 
628
        c.Assert(err, IsNil)
 
629
        c.Assert(num, Equals, 5)
 
630
        uuid2, err := newUUID()
 
631
        c.Assert(err, IsNil)
 
632
        c.Assert(uuid2, Not(Equals), uuid)
 
633
}
 
634
 
 
635
func (s *NovaHTTPSuite) TestRunServer(c *C) {
 
636
        entities := s.service.allServersAsEntities(nil)
 
637
        c.Assert(entities, HasLen, 0)
 
638
        var req struct {
 
639
                Server struct {
 
640
                        FlavorRef      string              `json:"flavorRef"`
 
641
                        ImageRef       string              `json:"imageRef"`
 
642
                        Name           string              `json:"name"`
 
643
                        SecurityGroups []map[string]string `json:"security_groups"`
 
644
                } `json:"server"`
 
645
        }
 
646
        resp, err := s.jsonRequest("POST", "/servers", req, nil)
 
647
        c.Assert(err, IsNil)
 
648
        c.Assert(resp.StatusCode, Equals, http.StatusBadRequest)
 
649
        assertBody(c, resp, errBadRequestSrvName)
 
650
        req.Server.Name = "srv1"
 
651
        resp, err = s.jsonRequest("POST", "/servers", req, nil)
 
652
        c.Assert(err, IsNil)
 
653
        c.Assert(resp.StatusCode, Equals, http.StatusBadRequest)
 
654
        assertBody(c, resp, errBadRequestSrvImage)
 
655
        req.Server.ImageRef = "image"
 
656
        resp, err = s.jsonRequest("POST", "/servers", req, nil)
 
657
        c.Assert(err, IsNil)
 
658
        c.Assert(resp.StatusCode, Equals, http.StatusBadRequest)
 
659
        assertBody(c, resp, errBadRequestSrvFlavor)
 
660
        req.Server.FlavorRef = "flavor"
 
661
        var expected struct {
 
662
                Server struct {
 
663
                        SecurityGroups []map[string]string `json:"security_groups"`
 
664
                        Id             string
 
665
                        Links          []nova.Link
 
666
                        AdminPass      string
 
667
                }
 
668
        }
 
669
        resp, err = s.jsonRequest("POST", "/servers", req, nil)
 
670
        c.Assert(err, IsNil)
 
671
        c.Assert(resp.StatusCode, Equals, http.StatusAccepted)
 
672
        assertJSON(c, resp, &expected)
 
673
        c.Assert(expected.Server.SecurityGroups, HasLen, 1)
 
674
        c.Assert(expected.Server.SecurityGroups[0]["name"], Equals, "default")
 
675
        c.Assert(expected.Server.Id, Not(Equals), "")
 
676
        c.Assert(expected.Server.Links, HasLen, 2)
 
677
        c.Assert(expected.Server.AdminPass, Not(Equals), "")
 
678
        srv, err := s.service.server(expected.Server.Id)
 
679
        c.Assert(err, IsNil)
 
680
        c.Assert(srv.Links, DeepEquals, expected.Server.Links)
 
681
        s.service.removeServer(srv.Id)
 
682
        req.Server.Name = "test2"
 
683
        req.Server.SecurityGroups = []map[string]string{
 
684
                {"name": "group1"},
 
685
                {"name": "group2"},
 
686
        }
 
687
        err = s.service.addSecurityGroup(nova.SecurityGroup{Id: 1, Name: "group1"})
 
688
        c.Assert(err, IsNil)
 
689
        defer s.service.removeSecurityGroup(1)
 
690
        err = s.service.addSecurityGroup(nova.SecurityGroup{Id: 2, Name: "group2"})
 
691
        c.Assert(err, IsNil)
 
692
        defer s.service.removeSecurityGroup(2)
 
693
        resp, err = s.jsonRequest("POST", "/servers", req, nil)
 
694
        c.Assert(err, IsNil)
 
695
        c.Assert(resp.StatusCode, Equals, http.StatusAccepted)
 
696
        assertJSON(c, resp, &expected)
 
697
        c.Assert(expected.Server.SecurityGroups, DeepEquals, req.Server.SecurityGroups)
 
698
        srv, err = s.service.server(expected.Server.Id)
 
699
        c.Assert(err, IsNil)
 
700
        ok := s.service.hasServerSecurityGroup(srv.Id, 1)
 
701
        c.Assert(ok, Equals, true)
 
702
        ok = s.service.hasServerSecurityGroup(srv.Id, 2)
 
703
        c.Assert(ok, Equals, true)
 
704
        s.service.removeServerSecurityGroup(srv.Id, 1)
 
705
        s.service.removeServerSecurityGroup(srv.Id, 2)
 
706
        s.service.removeServer(srv.Id)
 
707
}
 
708
 
582
709
func (s *NovaHTTPSuite) TestDeleteServer(c *C) {
583
710
        server := nova.ServerDetail{Id: "sr1"}
584
711
        _, err := s.service.server(server.Id)
585
712
        c.Assert(err, NotNil)
586
713
        err = s.service.addServer(server)
 
714
        c.Assert(err, IsNil)
587
715
        defer s.service.removeServer(server.Id)
588
 
        c.Assert(err, IsNil)
589
716
        resp, err := s.authRequest("DELETE", "/servers/sr1", nil, nil)
590
717
        c.Assert(err, IsNil)
591
718
        c.Assert(resp.StatusCode, Equals, http.StatusNoContent)
594
721
}
595
722
 
596
723
func (s *NovaHTTPSuite) TestGetServersDetail(c *C) {
597
 
        servers := s.service.allServers()
 
724
        servers := s.service.allServers(nil)
598
725
        c.Assert(servers, HasLen, 0)
599
726
        var expected struct {
600
727
                Servers []nova.ServerDetail `json:"servers"`
605
732
        assertJSON(c, resp, &expected)
606
733
        c.Assert(expected.Servers, HasLen, 0)
607
734
        servers = []nova.ServerDetail{
608
 
                nova.ServerDetail{Id: "sr1", Name: "server 1"},
609
 
                nova.ServerDetail{Id: "sr2", Name: "server 2"},
 
735
                {Id: "sr1", Name: "server 1"},
 
736
                {Id: "sr2", Name: "server 2"},
610
737
        }
611
738
        for i, server := range servers {
612
739
                s.service.buildServerLinks(&server)
613
740
                servers[i] = server
614
741
                err := s.service.addServer(server)
 
742
                c.Assert(err, IsNil)
615
743
                defer s.service.removeServer(server.Id)
616
 
                c.Assert(err, IsNil)
617
744
        }
618
745
        resp, err = s.authRequest("GET", "/servers/detail", nil, nil)
619
746
        c.Assert(err, IsNil)
620
747
        c.Assert(resp.StatusCode, Equals, http.StatusOK)
621
748
        assertJSON(c, resp, &expected)
 
749
        c.Assert(expected.Servers, HasLen, 2)
622
750
        if expected.Servers[0].Id != servers[0].Id {
623
751
                expected.Servers[0], expected.Servers[1] = expected.Servers[1], expected.Servers[0]
624
752
        }
628
756
        assertBody(c, resp, errNotFound)
629
757
}
630
758
 
 
759
func (s *NovaHTTPSuite) TestGetServersDetailWithFilters(c *C) {
 
760
        servers := s.service.allServers(nil)
 
761
        c.Assert(servers, HasLen, 0)
 
762
        var expected struct {
 
763
                Servers []nova.ServerDetail `json:"servers"`
 
764
        }
 
765
        url := "/servers/detail?status=RESCUE&status=BUILD&name=srv1&name=srv2"
 
766
        resp, err := s.authRequest("GET", url, nil, nil)
 
767
        c.Assert(err, IsNil)
 
768
        c.Assert(resp.StatusCode, Equals, http.StatusOK)
 
769
        assertJSON(c, resp, &expected)
 
770
        c.Assert(expected.Servers, HasLen, 0)
 
771
        servers = []nova.ServerDetail{
 
772
                {Id: "sr1", Name: "srv1", Status: nova.StatusBuild},
 
773
                {Id: "sr2", Name: "srv2", Status: nova.StatusRescue},
 
774
                {Id: "sr3", Name: "srv3", Status: nova.StatusActive},
 
775
        }
 
776
        for i, server := range servers {
 
777
                s.service.buildServerLinks(&server)
 
778
                servers[i] = server
 
779
                err := s.service.addServer(server)
 
780
                c.Assert(err, IsNil)
 
781
                defer s.service.removeServer(server.Id)
 
782
        }
 
783
        resp, err = s.authRequest("GET", url, nil, nil)
 
784
        c.Assert(err, IsNil)
 
785
        c.Assert(resp.StatusCode, Equals, http.StatusOK)
 
786
        assertJSON(c, resp, &expected)
 
787
        c.Assert(expected.Servers, HasLen, 2)
 
788
        if expected.Servers[0].Id != servers[0].Id {
 
789
                expected.Servers[0], expected.Servers[1] = expected.Servers[1], expected.Servers[0]
 
790
        }
 
791
        c.Assert(expected.Servers, DeepEquals, servers[:2])
 
792
}
 
793
 
631
794
func (s *NovaHTTPSuite) TestGetSecurityGroups(c *C) {
632
795
        groups := s.service.allSecurityGroups()
633
796
        c.Assert(groups, HasLen, 0)
640
803
        assertJSON(c, resp, &expected)
641
804
        c.Assert(expected.Groups, HasLen, 0)
642
805
        groups = []nova.SecurityGroup{
643
 
                nova.SecurityGroup{Id: 1, Name: "group 1"},
644
 
                nova.SecurityGroup{Id: 2, Name: "group 2"},
 
806
                {Id: 1, Name: "group 1"},
 
807
                {Id: 2, Name: "group 2"},
645
808
        }
646
809
        for _, group := range groups {
647
810
                err := s.service.addSecurityGroup(group)
 
811
                c.Assert(err, IsNil)
648
812
                defer s.service.removeSecurityGroup(group.Id)
649
 
                c.Assert(err, IsNil)
650
813
        }
651
814
        resp, err = s.authRequest("GET", "/os-security-groups", nil, nil)
652
815
        c.Assert(err, IsNil)
695
858
        _, err := s.service.securityGroup(group.Id)
696
859
        c.Assert(err, NotNil)
697
860
        err = s.service.addSecurityGroup(group)
 
861
        c.Assert(err, IsNil)
698
862
        defer s.service.removeSecurityGroup(group.Id)
699
 
        c.Assert(err, IsNil)
700
863
        resp, err := s.authRequest("DELETE", "/os-security-groups/1", nil, nil)
701
864
        c.Assert(err, IsNil)
702
865
        c.Assert(resp.StatusCode, Equals, http.StatusNoContent)
708
871
        group1 := nova.SecurityGroup{Id: 1, Name: "src", TenantId: "joe"}
709
872
        group2 := nova.SecurityGroup{Id: 2, Name: "tgt"}
710
873
        err := s.service.addSecurityGroup(group1)
 
874
        c.Assert(err, IsNil)
711
875
        defer s.service.removeSecurityGroup(group1.Id)
712
 
        c.Assert(err, IsNil)
713
876
        err = s.service.addSecurityGroup(group2)
 
877
        c.Assert(err, IsNil)
714
878
        defer s.service.removeSecurityGroup(group2.Id)
715
 
        c.Assert(err, IsNil)
716
879
        riIngress := nova.RuleInfo{
717
880
                ParentGroupId: 1,
718
881
                FromPort:      1234,
765
928
        c.Assert(*expected.Rule.IPProtocol, Equals, *rule1.IPProtocol)
766
929
        c.Assert(expected.Rule.IPRange, DeepEquals, rule1.IPRange)
767
930
        defer s.service.removeSecurityGroupRule(rule1.Id)
768
 
        c.Assert(err, IsNil)
769
931
        req.Rule = riGroup
770
932
        resp, err = s.jsonRequest("POST", "/os-security-group-rules", req, nil)
771
933
        c.Assert(err, IsNil)
782
944
        group1 := nova.SecurityGroup{Id: 1, Name: "src", TenantId: "joe"}
783
945
        group2 := nova.SecurityGroup{Id: 2, Name: "tgt"}
784
946
        err := s.service.addSecurityGroup(group1)
 
947
        c.Assert(err, IsNil)
785
948
        defer s.service.removeSecurityGroup(group1.Id)
786
 
        c.Assert(err, IsNil)
787
949
        err = s.service.addSecurityGroup(group2)
 
950
        c.Assert(err, IsNil)
788
951
        defer s.service.removeSecurityGroup(group2.Id)
789
 
        c.Assert(err, IsNil)
790
952
        riGroup := nova.RuleInfo{
791
953
                ParentGroupId: group2.Id,
792
954
                GroupId:       &group1.Id,
811
973
func (s *NovaHTTPSuite) TestAddServerSecurityGroup(c *C) {
812
974
        group := nova.SecurityGroup{Id: 1, Name: "group"}
813
975
        err := s.service.addSecurityGroup(group)
 
976
        c.Assert(err, IsNil)
814
977
        defer s.service.removeSecurityGroup(group.Id)
815
 
        c.Assert(err, IsNil)
816
978
        server := nova.ServerDetail{Id: "sr1"}
817
979
        err = s.service.addServer(server)
 
980
        c.Assert(err, IsNil)
818
981
        defer s.service.removeServer(server.Id)
819
 
        c.Assert(err, IsNil)
820
982
        ok := s.service.hasServerSecurityGroup(server.Id, group.Id)
821
983
        c.Assert(ok, Equals, false)
822
984
        var req struct {
837
999
func (s *NovaHTTPSuite) TestGetServerSecurityGroups(c *C) {
838
1000
        server := nova.ServerDetail{Id: "sr1"}
839
1001
        groups := []nova.SecurityGroup{
840
 
                nova.SecurityGroup{Id: 1, Name: "group1"},
841
 
                nova.SecurityGroup{Id: 2, Name: "group2"},
 
1002
                {Id: 1, Name: "group1"},
 
1003
                {Id: 2, Name: "group2"},
842
1004
        }
843
1005
        srvGroups := s.service.allServerSecurityGroups(server.Id)
844
1006
        c.Assert(srvGroups, HasLen, 0)
845
1007
        err := s.service.addServer(server)
 
1008
        c.Assert(err, IsNil)
846
1009
        defer s.service.removeServer(server.Id)
847
 
        c.Assert(err, IsNil)
848
1010
        for _, group := range groups {
849
1011
                err = s.service.addSecurityGroup(group)
 
1012
                c.Assert(err, IsNil)
850
1013
                defer s.service.removeSecurityGroup(group.Id)
851
 
                c.Assert(err, IsNil)
852
1014
                err = s.service.addServerSecurityGroup(server.Id, group.Id)
 
1015
                c.Assert(err, IsNil)
853
1016
                defer s.service.removeServerSecurityGroup(server.Id, group.Id)
854
 
                c.Assert(err, IsNil)
855
1017
        }
856
1018
        srvGroups = s.service.allServerSecurityGroups(server.Id)
857
1019
        var expected struct {
866
1028
func (s *NovaHTTPSuite) TestDeleteServerSecurityGroup(c *C) {
867
1029
        group := nova.SecurityGroup{Id: 1, Name: "group"}
868
1030
        err := s.service.addSecurityGroup(group)
 
1031
        c.Assert(err, IsNil)
869
1032
        defer s.service.removeSecurityGroup(group.Id)
870
 
        c.Assert(err, IsNil)
871
1033
        server := nova.ServerDetail{Id: "sr1"}
872
1034
        err = s.service.addServer(server)
 
1035
        c.Assert(err, IsNil)
873
1036
        defer s.service.removeServer(server.Id)
874
 
        c.Assert(err, IsNil)
875
1037
        ok := s.service.hasServerSecurityGroup(server.Id, group.Id)
876
1038
        c.Assert(ok, Equals, false)
877
1039
        err = s.service.addServerSecurityGroup(server.Id, group.Id)
915
1077
        assertJSON(c, resp, &expected)
916
1078
        c.Assert(expected.IPs, HasLen, 0)
917
1079
        fips := []nova.FloatingIP{
918
 
                nova.FloatingIP{Id: 1, IP: "1.2.3.4", Pool: "nova"},
919
 
                nova.FloatingIP{Id: 2, IP: "4.3.2.1", Pool: "nova"},
 
1080
                {Id: 1, IP: "1.2.3.4", Pool: "nova"},
 
1081
                {Id: 2, IP: "4.3.2.1", Pool: "nova"},
920
1082
        }
921
1083
        for _, fip := range fips {
922
1084
                err := s.service.addFloatingIP(fip)
944
1106
func (s *NovaHTTPSuite) TestDeleteFloatingIP(c *C) {
945
1107
        fip := nova.FloatingIP{Id: 1, IP: "10.0.0.1", Pool: "nova"}
946
1108
        err := s.service.addFloatingIP(fip)
 
1109
        c.Assert(err, IsNil)
947
1110
        defer s.service.removeFloatingIP(fip.Id)
948
 
        c.Assert(err, IsNil)
949
1111
        resp, err := s.authRequest("DELETE", "/os-floating-ips/1", nil, nil)
950
1112
        c.Assert(err, IsNil)
951
1113
        c.Assert(resp.StatusCode, Equals, http.StatusAccepted)
957
1119
        fip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"}
958
1120
        server := nova.ServerDetail{Id: "sr1"}
959
1121
        err := s.service.addFloatingIP(fip)
 
1122
        c.Assert(err, IsNil)
960
1123
        defer s.service.removeFloatingIP(fip.Id)
961
 
        c.Assert(err, IsNil)
962
1124
        err = s.service.addServer(server)
 
1125
        c.Assert(err, IsNil)
963
1126
        defer s.service.removeServer(server.Id)
964
 
        c.Assert(err, IsNil)
965
1127
        c.Assert(s.service.hasServerFloatingIP(server.Id, fip.IP), Equals, false)
966
1128
        var req struct {
967
1129
                AddFloatingIP struct {
981
1143
        fip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"}
982
1144
        server := nova.ServerDetail{Id: "sr1"}
983
1145
        err := s.service.addFloatingIP(fip)
 
1146
        c.Assert(err, IsNil)
984
1147
        defer s.service.removeFloatingIP(fip.Id)
985
 
        c.Assert(err, IsNil)
986
1148
        err = s.service.addServer(server)
 
1149
        c.Assert(err, IsNil)
987
1150
        defer s.service.removeServer(server.Id)
988
 
        c.Assert(err, IsNil)
989
1151
        err = s.service.addServerFloatingIP(server.Id, fip.Id)
 
1152
        c.Assert(err, IsNil)
990
1153
        defer s.service.removeServerFloatingIP(server.Id, fip.Id)
991
 
        c.Assert(err, IsNil)
992
1154
        c.Assert(s.service.hasServerFloatingIP(server.Id, fip.IP), Equals, true)
993
1155
        var req struct {
994
1156
                RemoveFloatingIP struct {