github.com/mwhudson/juju@v0.0.0-20160512215208-90ff01f3497f/provider/ec2/environ_test.go (about)

     1  // Copyright 2011, 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package ec2
     5  
     6  import (
     7  	amzec2 "gopkg.in/amz.v3/ec2"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/constraints"
    11  	"github.com/juju/juju/environs"
    12  	"github.com/juju/juju/environs/simplestreams"
    13  	"github.com/juju/juju/network"
    14  	"github.com/juju/juju/state"
    15  )
    16  
    17  // Ensure EC2 provider supports the expected interfaces,
    18  var (
    19  	_ environs.NetworkingEnviron = (*environ)(nil)
    20  	_ simplestreams.HasRegion    = (*environ)(nil)
    21  	_ state.Prechecker           = (*environ)(nil)
    22  	_ state.InstanceDistributor  = (*environ)(nil)
    23  )
    24  
    25  type Suite struct{}
    26  
    27  var _ = gc.Suite(&Suite{})
    28  
    29  type RootDiskTest struct {
    30  	series     string
    31  	name       string
    32  	constraint *uint64
    33  	device     amzec2.BlockDeviceMapping
    34  }
    35  
    36  var commonInstanceStoreDisks = []amzec2.BlockDeviceMapping{{
    37  	DeviceName:  "/dev/sdb",
    38  	VirtualName: "ephemeral0",
    39  }, {
    40  	DeviceName:  "/dev/sdc",
    41  	VirtualName: "ephemeral1",
    42  }, {
    43  	DeviceName:  "/dev/sdd",
    44  	VirtualName: "ephemeral2",
    45  }, {
    46  	DeviceName:  "/dev/sde",
    47  	VirtualName: "ephemeral3",
    48  }}
    49  
    50  func (*Suite) TestRootDiskBlockDeviceMapping(c *gc.C) {
    51  	var rootDiskTests = []RootDiskTest{{
    52  		"trusty",
    53  		"nil constraint ubuntu",
    54  		nil,
    55  		amzec2.BlockDeviceMapping{VolumeSize: 8, DeviceName: "/dev/sda1"},
    56  	}, {
    57  		"trusty",
    58  		"too small constraint ubuntu",
    59  		pInt(4000),
    60  		amzec2.BlockDeviceMapping{VolumeSize: 8, DeviceName: "/dev/sda1"},
    61  	}, {
    62  		"trusty",
    63  		"big constraint ubuntu",
    64  		pInt(20 * 1024),
    65  		amzec2.BlockDeviceMapping{VolumeSize: 20, DeviceName: "/dev/sda1"},
    66  	}, {
    67  		"trusty",
    68  		"round up constraint ubuntu",
    69  		pInt(20*1024 + 1),
    70  		amzec2.BlockDeviceMapping{VolumeSize: 21, DeviceName: "/dev/sda1"},
    71  	}, {
    72  		"win2012r2",
    73  		"nil constraint windows",
    74  		nil,
    75  		amzec2.BlockDeviceMapping{VolumeSize: 40, DeviceName: "/dev/sda1"},
    76  	}, {
    77  		"win2012r2",
    78  		"too small constraint windows",
    79  		pInt(30 * 1024),
    80  		amzec2.BlockDeviceMapping{VolumeSize: 40, DeviceName: "/dev/sda1"},
    81  	}, {
    82  		"win2012r2",
    83  		"big constraint windows",
    84  		pInt(50 * 1024),
    85  		amzec2.BlockDeviceMapping{VolumeSize: 50, DeviceName: "/dev/sda1"},
    86  	}, {
    87  		"win2012r2",
    88  		"round up constraint windows",
    89  		pInt(50*1024 + 1),
    90  		amzec2.BlockDeviceMapping{VolumeSize: 51, DeviceName: "/dev/sda1"},
    91  	}}
    92  
    93  	for _, t := range rootDiskTests {
    94  		c.Logf("Test %s", t.name)
    95  		cons := constraints.Value{RootDisk: t.constraint}
    96  		mappings := getBlockDeviceMappings(cons, t.series)
    97  		expected := append([]amzec2.BlockDeviceMapping{t.device}, commonInstanceStoreDisks...)
    98  		c.Assert(mappings, gc.DeepEquals, expected)
    99  	}
   100  }
   101  
   102  func pInt(i uint64) *uint64 {
   103  	return &i
   104  }
   105  
   106  func (*Suite) TestPortsToIPPerms(c *gc.C) {
   107  	testCases := []struct {
   108  		about    string
   109  		ports    []network.PortRange
   110  		expected []amzec2.IPPerm
   111  	}{{
   112  		about: "single port",
   113  		ports: []network.PortRange{{
   114  			FromPort: 80,
   115  			ToPort:   80,
   116  			Protocol: "tcp",
   117  		}},
   118  		expected: []amzec2.IPPerm{{
   119  			Protocol:  "tcp",
   120  			FromPort:  80,
   121  			ToPort:    80,
   122  			SourceIPs: []string{"0.0.0.0/0"},
   123  		}},
   124  	}, {
   125  		about: "multiple ports",
   126  		ports: []network.PortRange{{
   127  			FromPort: 80,
   128  			ToPort:   82,
   129  			Protocol: "tcp",
   130  		}},
   131  		expected: []amzec2.IPPerm{{
   132  			Protocol:  "tcp",
   133  			FromPort:  80,
   134  			ToPort:    82,
   135  			SourceIPs: []string{"0.0.0.0/0"},
   136  		}},
   137  	}, {
   138  		about: "multiple port ranges",
   139  		ports: []network.PortRange{{
   140  			FromPort: 80,
   141  			ToPort:   82,
   142  			Protocol: "tcp",
   143  		}, {
   144  			FromPort: 100,
   145  			ToPort:   120,
   146  			Protocol: "tcp",
   147  		}},
   148  		expected: []amzec2.IPPerm{{
   149  			Protocol:  "tcp",
   150  			FromPort:  80,
   151  			ToPort:    82,
   152  			SourceIPs: []string{"0.0.0.0/0"},
   153  		}, {
   154  			Protocol:  "tcp",
   155  			FromPort:  100,
   156  			ToPort:    120,
   157  			SourceIPs: []string{"0.0.0.0/0"},
   158  		}},
   159  	}}
   160  
   161  	for i, t := range testCases {
   162  		c.Logf("test %d: %s", i, t.about)
   163  		ipperms := portsToIPPerms(t.ports)
   164  		c.Assert(ipperms, gc.DeepEquals, t.expected)
   165  	}
   166  }