← Back to branch summary

~ubuntu-branches/ubuntu/saucy/juju-core/saucy-proposed

« back to all changes in this revision

Viewing changes to src/launchpad.net/goose/testservices/novaservice/service_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-07-11 17:18:27 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20130711171827-vjqkg40r0dlf7ys2
Tags: 1.11.2-0ubuntu1
https://launchpad.net/bugs/1190634
https://launchpad.net/bugs/1172505
* New upstream release.
* Make juju-core the default juju (LP: #1190634):
  - d/control: Add virtual package juju -> juju-core.
  - d/juju-core.postinst.in: Bump priority of alternatives over that of
    python juju packages.
* Enable for all architectures (LP: #1172505):
  - d/control: Version BD on golang-go to >= 2:1.1.1 to ensure CGO
    support for non-x86 archs, make juju-core Arch: any.
  - d/README.source: Dropped - no longer required.
* d/watch: Updated for new upstream tarball naming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/goose/testservices/novaservice/service_test.go
36
36
 
37
37
func (s *NovaSuite) ensureNoGroup(c *C, group nova.SecurityGroup) {
38
38
        _, err := s.service.securityGroup(group.Id)
39
 
        c.Assert(err, ErrorMatches, fmt.Sprintf("no such security group %d", group.Id))
 
39
        c.Assert(err, ErrorMatches, fmt.Sprintf("no such security group %s", group.Id))
40
40
}
41
41
 
42
42
func (s *NovaSuite) ensureNoRule(c *C, rule nova.SecurityGroupRule) {
43
43
        _, err := s.service.securityGroupRule(rule.Id)
44
 
        c.Assert(err, ErrorMatches, fmt.Sprintf("no such security group rule %d", rule.Id))
 
44
        c.Assert(err, ErrorMatches, fmt.Sprintf("no such security group rule %s", rule.Id))
45
45
}
46
46
 
47
47
func (s *NovaSuite) ensureNoIP(c *C, ip nova.FloatingIP) {
48
48
        _, err := s.service.floatingIP(ip.Id)
49
 
        c.Assert(err, ErrorMatches, fmt.Sprintf("no such floating IP %d", ip.Id))
 
49
        c.Assert(err, ErrorMatches, fmt.Sprintf("no such floating IP %s", ip.Id))
50
50
}
51
51
 
52
52
func (s *NovaSuite) createFlavor(c *C, flavor nova.FlavorDetail) {
520
520
}
521
521
 
522
522
func (s *NovaSuite) TestAddRemoveSecurityGroup(c *C) {
523
 
        group := nova.SecurityGroup{Id: 1}
 
523
        group := nova.SecurityGroup{Id: "1"}
524
524
        s.createGroup(c, group)
525
525
        s.deleteGroup(c, group)
526
526
}
527
527
 
528
528
func (s *NovaSuite) TestAddSecurityGroupWithRules(c *C) {
529
529
        group := nova.SecurityGroup{
530
 
                Id:       1,
 
530
                Id:       "1",
531
531
                Name:     "test",
532
532
                TenantId: s.service.TenantId,
533
533
                Rules: []nova.SecurityGroupRule{
534
 
                        {Id: 10, ParentGroupId: 1},
535
 
                        {Id: 20, ParentGroupId: 1},
 
534
                        {Id: "10", ParentGroupId: "1"},
 
535
                        {Id: "20", ParentGroupId: "1"},
536
536
                },
537
537
        }
538
538
        s.createGroup(c, group)
542
542
}
543
543
 
544
544
func (s *NovaSuite) TestAddSecurityGroupTwiceFails(c *C) {
545
 
        group := nova.SecurityGroup{Id: 1, Name: "test"}
 
545
        group := nova.SecurityGroup{Id: "1", Name: "test"}
546
546
        s.createGroup(c, group)
547
547
        defer s.deleteGroup(c, group)
548
548
        err := s.service.addSecurityGroup(group)
550
550
}
551
551
 
552
552
func (s *NovaSuite) TestRemoveSecurityGroupTwiceFails(c *C) {
553
 
        group := nova.SecurityGroup{Id: 1, Name: "test"}
 
553
        group := nova.SecurityGroup{Id: "1", Name: "test"}
554
554
        s.createGroup(c, group)
555
555
        s.deleteGroup(c, group)
556
556
        err := s.service.removeSecurityGroup(group.Id)
563
563
        c.Assert(groups, HasLen, 1)
564
564
        groups = []nova.SecurityGroup{
565
565
                {
566
 
                        Id:       1,
 
566
                        Id:       "1",
567
567
                        Name:     "one",
568
568
                        TenantId: s.service.TenantId,
569
569
                        Rules:    []nova.SecurityGroupRule{},
570
570
                },
571
571
                {
572
 
                        Id:       2,
 
572
                        Id:       "2",
573
573
                        Name:     "two",
574
574
                        TenantId: s.service.TenantId,
575
575
                        Rules:    []nova.SecurityGroupRule{},
586
586
 
587
587
func (s *NovaSuite) TestGetSecurityGroup(c *C) {
588
588
        group := nova.SecurityGroup{
589
 
                Id:          42,
 
589
                Id:          "42",
590
590
                TenantId:    s.service.TenantId,
591
591
                Name:        "group",
592
592
                Description: "desc",
600
600
 
601
601
func (s *NovaSuite) TestGetSecurityGroupByName(c *C) {
602
602
        group := nova.SecurityGroup{
603
 
                Id:       1,
 
603
                Id:       "1",
604
604
                Name:     "test",
605
605
                TenantId: s.service.TenantId,
606
606
                Rules:    []nova.SecurityGroupRule{},
616
616
}
617
617
 
618
618
func (s *NovaSuite) TestAddHasRemoveSecurityGroupRule(c *C) {
619
 
        group := nova.SecurityGroup{Id: 1}
 
619
        group := nova.SecurityGroup{Id: "1"}
620
620
        ri := nova.RuleInfo{ParentGroupId: group.Id}
621
 
        rule := nova.SecurityGroupRule{Id: 10, ParentGroupId: group.Id}
 
621
        rule := nova.SecurityGroupRule{Id: "10", ParentGroupId: group.Id}
622
622
        s.ensureNoGroup(c, group)
623
623
        s.ensureNoRule(c, rule)
624
624
        ok := s.service.hasSecurityGroupRule(group.Id, rule.Id)
629
629
        ok = s.service.hasSecurityGroupRule(group.Id, rule.Id)
630
630
        c.Assert(ok, Equals, true)
631
631
        s.deleteGroup(c, group)
632
 
        ok = s.service.hasSecurityGroupRule(-1, rule.Id)
 
632
        ok = s.service.hasSecurityGroupRule("-1", rule.Id)
633
633
        c.Assert(ok, Equals, true)
634
634
        ok = s.service.hasSecurityGroupRule(group.Id, rule.Id)
635
635
        c.Assert(ok, Equals, false)
636
636
        s.deleteRule(c, rule)
637
 
        ok = s.service.hasSecurityGroupRule(-1, rule.Id)
 
637
        ok = s.service.hasSecurityGroupRule("-1", rule.Id)
638
638
        c.Assert(ok, Equals, false)
639
639
}
640
640
 
641
641
func (s *NovaSuite) TestAddGetIngressSecurityGroupRule(c *C) {
642
 
        group := nova.SecurityGroup{Id: 1}
 
642
        group := nova.SecurityGroup{Id: "1"}
643
643
        s.createGroup(c, group)
644
644
        defer s.deleteGroup(c, group)
645
645
        ri := nova.RuleInfo{
650
650
                ParentGroupId: group.Id,
651
651
        }
652
652
        rule := nova.SecurityGroupRule{
653
 
                Id:            10,
 
653
                Id:            "10",
654
654
                ParentGroupId: group.Id,
655
655
                FromPort:      &ri.FromPort,
656
656
                ToPort:        &ri.ToPort,
673
673
}
674
674
 
675
675
func (s *NovaSuite) TestAddGetGroupSecurityGroupRule(c *C) {
676
 
        srcGroup := nova.SecurityGroup{Id: 1, Name: "source", TenantId: s.service.TenantId}
677
 
        tgtGroup := nova.SecurityGroup{Id: 2, Name: "target"}
 
676
        srcGroup := nova.SecurityGroup{Id: "1", Name: "source", TenantId: s.service.TenantId}
 
677
        tgtGroup := nova.SecurityGroup{Id: "2", Name: "target"}
678
678
        s.createGroup(c, srcGroup)
679
679
        defer s.deleteGroup(c, srcGroup)
680
680
        s.createGroup(c, tgtGroup)
687
687
                ParentGroupId: tgtGroup.Id,
688
688
        }
689
689
        rule := nova.SecurityGroupRule{
690
 
                Id:            10,
 
690
                Id:            "10",
691
691
                ParentGroupId: tgtGroup.Id,
692
692
                FromPort:      &ri.FromPort,
693
693
                ToPort:        &ri.ToPort,
712
712
}
713
713
 
714
714
func (s *NovaSuite) TestAddSecurityGroupRuleTwiceFails(c *C) {
715
 
        group := nova.SecurityGroup{Id: 1}
 
715
        group := nova.SecurityGroup{Id: "1"}
716
716
        s.createGroup(c, group)
717
717
        defer s.deleteGroup(c, group)
718
718
        ri := nova.RuleInfo{ParentGroupId: group.Id}
719
 
        rule := nova.SecurityGroupRule{Id: 10}
 
719
        rule := nova.SecurityGroupRule{Id: "10"}
720
720
        s.ensureNoRule(c, rule)
721
721
        err := s.service.addSecurityGroupRule(rule.Id, ri)
722
722
        c.Assert(err, IsNil)
727
727
 
728
728
func (s *NovaSuite) TestAddSecurityGroupRuleToParentTwiceFails(c *C) {
729
729
        group := nova.SecurityGroup{
730
 
                Id: 1,
 
730
                Id: "1",
731
731
                Rules: []nova.SecurityGroupRule{
732
 
                        {Id: 10},
 
732
                        {Id: "10"},
733
733
                },
734
734
        }
735
735
        s.createGroup(c, group)
736
736
        defer s.deleteGroup(c, group)
737
737
        ri := nova.RuleInfo{ParentGroupId: group.Id}
738
 
        rule := nova.SecurityGroupRule{Id: 10}
 
738
        rule := nova.SecurityGroupRule{Id: "10"}
739
739
        err := s.service.addSecurityGroupRule(rule.Id, ri)
740
740
        c.Assert(err, ErrorMatches, "cannot add twice rule 10 to security group 1")
741
741
}
742
742
 
743
743
func (s *NovaSuite) TestAddSecurityGroupRuleWithInvalidParentFails(c *C) {
744
 
        invalidGroup := nova.SecurityGroup{Id: 1}
 
744
        invalidGroup := nova.SecurityGroup{Id: "1"}
745
745
        s.ensureNoGroup(c, invalidGroup)
746
746
        ri := nova.RuleInfo{ParentGroupId: invalidGroup.Id}
747
 
        rule := nova.SecurityGroupRule{Id: 10}
 
747
        rule := nova.SecurityGroupRule{Id: "10"}
748
748
        s.ensureNoRule(c, rule)
749
749
        err := s.service.addSecurityGroupRule(rule.Id, ri)
750
750
        c.Assert(err, ErrorMatches, "no such security group 1")
751
751
}
752
752
 
753
753
func (s *NovaSuite) TestAddGroupSecurityGroupRuleWithInvalidSourceFails(c *C) {
754
 
        group := nova.SecurityGroup{Id: 1}
 
754
        group := nova.SecurityGroup{Id: "1"}
755
755
        s.createGroup(c, group)
756
756
        defer s.deleteGroup(c, group)
757
 
        invalidGroupId := 42
 
757
        invalidGroupId := "42"
758
758
        ri := nova.RuleInfo{
759
759
                ParentGroupId: group.Id,
760
760
                GroupId:       &invalidGroupId,
761
761
        }
762
 
        rule := nova.SecurityGroupRule{Id: 10}
 
762
        rule := nova.SecurityGroupRule{Id: "10"}
763
763
        s.ensureNoRule(c, rule)
764
764
        err := s.service.addSecurityGroupRule(rule.Id, ri)
765
765
        c.Assert(err, ErrorMatches, "unknown source security group 42")
767
767
 
768
768
func (s *NovaSuite) TestAddSecurityGroupRuleUpdatesParent(c *C) {
769
769
        group := nova.SecurityGroup{
770
 
                Id:       1,
 
770
                Id:       "1",
771
771
                Name:     "test",
772
772
                TenantId: s.service.TenantId,
773
773
        }
775
775
        defer s.deleteGroup(c, group)
776
776
        ri := nova.RuleInfo{ParentGroupId: group.Id}
777
777
        rule := nova.SecurityGroupRule{
778
 
                Id:            10,
 
778
                Id:            "10",
779
779
                ParentGroupId: group.Id,
780
780
                Group:         nova.SecurityGroupRef{},
781
781
        }
791
791
 
792
792
func (s *NovaSuite) TestAddSecurityGroupRuleKeepsNegativePort(c *C) {
793
793
        group := nova.SecurityGroup{
794
 
                Id:       1,
 
794
                Id:       "1",
795
795
                Name:     "test",
796
796
                TenantId: s.service.TenantId,
797
797
        }
805
805
                ParentGroupId: group.Id,
806
806
        }
807
807
        rule := nova.SecurityGroupRule{
808
 
                Id:            10,
 
808
                Id:            "10",
809
809
                ParentGroupId: group.Id,
810
810
                FromPort:      &ri.FromPort,
811
811
                ToPort:        &ri.ToPort,
822
822
}
823
823
 
824
824
func (s *NovaSuite) TestRemoveSecurityGroupRuleTwiceFails(c *C) {
825
 
        group := nova.SecurityGroup{Id: 1}
 
825
        group := nova.SecurityGroup{Id: "1"}
826
826
        s.createGroup(c, group)
827
827
        defer s.deleteGroup(c, group)
828
828
        ri := nova.RuleInfo{ParentGroupId: group.Id}
829
 
        rule := nova.SecurityGroupRule{Id: 10}
 
829
        rule := nova.SecurityGroupRule{Id: "10"}
830
830
        s.ensureNoRule(c, rule)
831
831
        err := s.service.addSecurityGroupRule(rule.Id, ri)
832
832
        c.Assert(err, IsNil)
837
837
 
838
838
func (s *NovaSuite) TestAddHasRemoveServerSecurityGroup(c *C) {
839
839
        server := nova.ServerDetail{Id: "sr1"}
840
 
        group := nova.SecurityGroup{Id: 1}
 
840
        group := nova.SecurityGroup{Id: "1"}
841
841
        s.ensureNoServer(c, server)
842
842
        s.ensureNoGroup(c, group)
843
843
        ok := s.service.hasServerSecurityGroup(server.Id, group.Id)
862
862
 
863
863
func (s *NovaSuite) TestAddServerSecurityGroupWithInvalidServerFails(c *C) {
864
864
        server := nova.ServerDetail{Id: "sr1"}
865
 
        group := nova.SecurityGroup{Id: 1}
 
865
        group := nova.SecurityGroup{Id: "1"}
866
866
        s.ensureNoServer(c, server)
867
867
        s.createGroup(c, group)
868
868
        defer s.deleteGroup(c, group)
871
871
}
872
872
 
873
873
func (s *NovaSuite) TestAddServerSecurityGroupWithInvalidGroupFails(c *C) {
874
 
        group := nova.SecurityGroup{Id: 1}
 
874
        group := nova.SecurityGroup{Id: "1"}
875
875
        server := nova.ServerDetail{Id: "sr1"}
876
876
        s.ensureNoGroup(c, group)
877
877
        s.createServer(c, server)
882
882
 
883
883
func (s *NovaSuite) TestAddServerSecurityGroupTwiceFails(c *C) {
884
884
        server := nova.ServerDetail{Id: "sr1"}
885
 
        group := nova.SecurityGroup{Id: 1}
 
885
        group := nova.SecurityGroup{Id: "1"}
886
886
        s.createServer(c, server)
887
887
        defer s.deleteServer(c, server)
888
888
        s.createGroup(c, group)
903
903
        defer s.deleteServer(c, server)
904
904
        groups := []nova.SecurityGroup{
905
905
                {
906
 
                        Id:       1,
 
906
                        Id:       "1",
907
907
                        Name:     "gr1",
908
908
                        TenantId: s.service.TenantId,
909
909
                        Rules:    []nova.SecurityGroupRule{},
910
910
                },
911
911
                {
912
 
                        Id:       2,
 
912
                        Id:       "2",
913
913
                        Name:     "gr2",
914
914
                        TenantId: s.service.TenantId,
915
915
                        Rules:    []nova.SecurityGroupRule{},
932
932
 
933
933
func (s *NovaSuite) TestRemoveServerSecurityGroupWithInvalidServerFails(c *C) {
934
934
        server := nova.ServerDetail{Id: "sr1"}
935
 
        group := nova.SecurityGroup{Id: 1}
 
935
        group := nova.SecurityGroup{Id: "1"}
936
936
        s.createServer(c, server)
937
937
        s.createGroup(c, group)
938
938
        defer s.deleteGroup(c, group)
948
948
}
949
949
 
950
950
func (s *NovaSuite) TestRemoveServerSecurityGroupWithInvalidGroupFails(c *C) {
951
 
        group := nova.SecurityGroup{Id: 1}
 
951
        group := nova.SecurityGroup{Id: "1"}
952
952
        server := nova.ServerDetail{Id: "sr1"}
953
953
        s.createGroup(c, group)
954
954
        s.createServer(c, server)
966
966
 
967
967
func (s *NovaSuite) TestRemoveServerSecurityGroupTwiceFails(c *C) {
968
968
        server := nova.ServerDetail{Id: "sr1"}
969
 
        group := nova.SecurityGroup{Id: 1}
 
969
        group := nova.SecurityGroup{Id: "1"}
970
970
        s.createServer(c, server)
971
971
        defer s.deleteServer(c, server)
972
972
        s.createGroup(c, group)
980
980
}
981
981
 
982
982
func (s *NovaSuite) TestAddHasRemoveFloatingIP(c *C) {
983
 
        ip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"}
 
983
        ip := nova.FloatingIP{Id: "1", IP: "1.2.3.4"}
984
984
        s.ensureNoIP(c, ip)
985
985
        ok := s.service.hasFloatingIP(ip.IP)
986
986
        c.Assert(ok, Equals, false)
995
995
}
996
996
 
997
997
func (s *NovaSuite) TestAddFloatingIPTwiceFails(c *C) {
998
 
        ip := nova.FloatingIP{Id: 1}
 
998
        ip := nova.FloatingIP{Id: "1"}
999
999
        s.createIP(c, ip)
1000
1000
        defer s.deleteIP(c, ip)
1001
1001
        err := s.service.addFloatingIP(ip)
1003
1003
}
1004
1004
 
1005
1005
func (s *NovaSuite) TestRemoveFloatingIPTwiceFails(c *C) {
1006
 
        ip := nova.FloatingIP{Id: 1}
 
1006
        ip := nova.FloatingIP{Id: "1"}
1007
1007
        s.createIP(c, ip)
1008
1008
        s.deleteIP(c, ip)
1009
1009
        err := s.service.removeFloatingIP(ip.Id)
1014
1014
        fips := s.service.allFloatingIPs()
1015
1015
        c.Assert(fips, HasLen, 0)
1016
1016
        fips = []nova.FloatingIP{
1017
 
                {Id: 1},
1018
 
                {Id: 2},
 
1017
                {Id: "1"},
 
1018
                {Id: "2"},
1019
1019
        }
1020
1020
        s.createIP(c, fips[0])
1021
1021
        defer s.deleteIP(c, fips[0])
1033
1033
        inst := "sr1"
1034
1034
        fixedIP := "4.3.2.1"
1035
1035
        fip := nova.FloatingIP{
1036
 
                Id:         1,
 
1036
                Id:         "1",
1037
1037
                IP:         "1.2.3.4",
1038
1038
                Pool:       "pool",
1039
1039
                InstanceId: &inst,
1046
1046
}
1047
1047
 
1048
1048
func (s *NovaSuite) TestGetFloatingIPByAddr(c *C) {
1049
 
        fip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"}
 
1049
        fip := nova.FloatingIP{Id: "1", IP: "1.2.3.4"}
1050
1050
        s.ensureNoIP(c, fip)
1051
1051
        ip, err := s.service.floatingIPByAddr(fip.IP)
1052
1052
        c.Assert(err, NotNil)
1061
1061
 
1062
1062
func (s *NovaSuite) TestAddHasRemoveServerFloatingIP(c *C) {
1063
1063
        server := nova.ServerDetail{Id: "sr1"}
1064
 
        fip := nova.FloatingIP{Id: 1, IP: "1.2.3.4"}
 
1064
        fip := nova.FloatingIP{Id: "1", IP: "1.2.3.4"}
1065
1065
        s.ensureNoServer(c, server)
1066
1066
        s.ensureNoIP(c, fip)
1067
1067
        ok := s.service.hasServerFloatingIP(server.Id, fip.IP)
1086
1086
 
1087
1087
func (s *NovaSuite) TestAddServerFloatingIPWithInvalidServerFails(c *C) {
1088
1088
        server := nova.ServerDetail{Id: "sr1"}
1089
 
        fip := nova.FloatingIP{Id: 1}
 
1089
        fip := nova.FloatingIP{Id: "1"}
1090
1090
        s.ensureNoServer(c, server)
1091
1091
        s.createIP(c, fip)
1092
1092
        defer s.deleteIP(c, fip)
1095
1095
}
1096
1096
 
1097
1097
func (s *NovaSuite) TestAddServerFloatingIPWithInvalidIPFails(c *C) {
1098
 
        fip := nova.FloatingIP{Id: 1}
 
1098
        fip := nova.FloatingIP{Id: "1"}
1099
1099
        server := nova.ServerDetail{Id: "sr1"}
1100
1100
        s.ensureNoIP(c, fip)
1101
1101
        s.createServer(c, server)
1106
1106
 
1107
1107
func (s *NovaSuite) TestAddServerFloatingIPTwiceFails(c *C) {
1108
1108
        server := nova.ServerDetail{Id: "sr1"}
1109
 
        fip := nova.FloatingIP{Id: 1}
 
1109
        fip := nova.FloatingIP{Id: "1"}
1110
1110
        s.createServer(c, server)
1111
1111
        defer s.deleteServer(c, server)
1112
1112
        s.createIP(c, fip)
1121
1121
 
1122
1122
func (s *NovaSuite) TestRemoveServerFloatingIPWithInvalidServerFails(c *C) {
1123
1123
        server := nova.ServerDetail{Id: "sr1"}
1124
 
        fip := nova.FloatingIP{Id: 1}
 
1124
        fip := nova.FloatingIP{Id: "1"}
1125
1125
        s.createServer(c, server)
1126
1126
        s.createIP(c, fip)
1127
1127
        defer s.deleteIP(c, fip)
1137
1137
}
1138
1138
 
1139
1139
func (s *NovaSuite) TestRemoveServerFloatingIPWithInvalidIPFails(c *C) {
1140
 
        fip := nova.FloatingIP{Id: 1}
 
1140
        fip := nova.FloatingIP{Id: "1"}
1141
1141
        server := nova.ServerDetail{Id: "sr1"}
1142
1142
        s.createIP(c, fip)
1143
1143
        s.createServer(c, server)
1155
1155
 
1156
1156
func (s *NovaSuite) TestRemoveServerFloatingIPTwiceFails(c *C) {
1157
1157
        server := nova.ServerDetail{Id: "sr1"}
1158
 
        fip := nova.FloatingIP{Id: 1}
 
1158
        fip := nova.FloatingIP{Id: "1"}
1159
1159
        s.createServer(c, server)
1160
1160
        defer s.deleteServer(c, server)
1161
1161
        s.createIP(c, fip)