1from tests.compat import mock, unittest
2
3from boto.ec2.snapshot import Snapshot
4from boto.ec2.tag import Tag, TagSet
5from boto.ec2.volume import Volume, AttachmentSet, VolumeAttribute
6
7
8class VolumeTests(unittest.TestCase):
9    def setUp(self):
10        self.attach_data = AttachmentSet()
11        self.attach_data.id = 1
12        self.attach_data.instance_id = 2
13        self.attach_data.status = "some status"
14        self.attach_data.attach_time = 5
15        self.attach_data.device = "/dev/null"
16
17        self.volume_one = Volume()
18        self.volume_one.id = 1
19        self.volume_one.create_time = 5
20        self.volume_one.status = "one_status"
21        self.volume_one.size = "one_size"
22        self.volume_one.snapshot_id = 1
23        self.volume_one.attach_data = self.attach_data
24        self.volume_one.zone = "one_zone"
25
26        self.volume_two = Volume()
27        self.volume_two.connection = mock.Mock()
28        self.volume_two.id = 1
29        self.volume_two.create_time = 6
30        self.volume_two.status = "two_status"
31        self.volume_two.size = "two_size"
32        self.volume_two.snapshot_id = 2
33        self.volume_two.attach_data = None
34        self.volume_two.zone = "two_zone"
35
36    @mock.patch("boto.ec2.volume.TaggedEC2Object.startElement")
37    def test_startElement_calls_TaggedEC2Object_startElement_with_correct_args(self, startElement):
38        volume = Volume()
39        volume.startElement("some name", "some attrs", None)
40        startElement.assert_called_with(
41            "some name",
42            "some attrs",
43            None
44        )
45
46    @mock.patch("boto.ec2.volume.TaggedEC2Object.startElement")
47    def test_startElement_retval_not_None_returns_correct_thing(self, startElement):
48        tag_set = mock.Mock(TagSet)
49        startElement.return_value = tag_set
50        volume = Volume()
51        retval = volume.startElement(None, None, None)
52        self.assertEqual(retval, tag_set)
53
54    @mock.patch("boto.ec2.volume.TaggedEC2Object.startElement")
55    @mock.patch("boto.resultset.ResultSet")
56    def test_startElement_with_name_tagSet_calls_ResultSet(self, ResultSet, startElement):
57        startElement.return_value = None
58        result_set = mock.Mock(ResultSet([("item", Tag)]))
59        volume = Volume()
60        volume.tags = result_set
61        retval = volume.startElement("tagSet", None, None)
62        self.assertEqual(retval, volume.tags)
63
64    @mock.patch("boto.ec2.volume.TaggedEC2Object.startElement")
65    def test_startElement_with_name_attachmentSet_returns_AttachmentSet(self, startElement):
66        startElement.return_value = None
67        attach_data = AttachmentSet()
68        volume = Volume()
69        volume.attach_data = attach_data
70        retval = volume.startElement("attachmentSet", None, None)
71        self.assertEqual(retval, volume.attach_data)
72
73    @mock.patch("boto.ec2.volume.TaggedEC2Object.startElement")
74    def test_startElement_else_returns_None(self, startElement):
75        startElement.return_value = None
76        volume = Volume()
77        retval = volume.startElement("not tagSet or attachmentSet", None, None)
78        self.assertEqual(retval, None)
79
80    def check_that_attribute_has_been_set(self, name, value, attribute, obj_value=None):
81        volume = Volume()
82        volume.endElement(name, value, None)
83        expected_value = obj_value if obj_value is not None else value
84        self.assertEqual(getattr(volume, attribute), expected_value)
85
86    def test_endElement_sets_correct_attributes_with_values(self):
87        for arguments in [("volumeId", "some value", "id"),
88                          ("createTime", "some time", "create_time"),
89                          ("status", "some status", "status"),
90                          ("size", 5, "size"),
91                          ("snapshotId", 1, "snapshot_id"),
92                          ("availabilityZone", "some zone", "zone"),
93                          ("someName", "some value", "someName"),
94                          ("encrypted", "true", "encrypted", True)]:
95            self.check_that_attribute_has_been_set(*arguments)
96
97    def test_endElement_with_name_status_and_empty_string_value_doesnt_set_status(self):
98        volume = Volume()
99        volume.endElement("status", "", None)
100        self.assertNotEqual(volume.status, "")
101
102    def test_update_with_result_set_greater_than_0_updates_dict(self):
103        self.volume_two.connection.get_all_volumes.return_value = [self.volume_one]
104        self.volume_two.update()
105
106        assert all([self.volume_two.create_time == 5,
107                    self.volume_two.status == "one_status",
108                    self.volume_two.size == "one_size",
109                    self.volume_two.snapshot_id == 1,
110                    self.volume_two.attach_data == self.attach_data,
111                    self.volume_two.zone == "one_zone"])
112
113    def test_update_with_validate_true_raises_value_error(self):
114        self.volume_one.connection = mock.Mock()
115        self.volume_one.connection.get_all_volumes.return_value = []
116        with self.assertRaisesRegexp(ValueError, "^1 is not a valid Volume ID$"):
117            self.volume_one.update(True)
118
119    def test_update_returns_status(self):
120        self.volume_one.connection = mock.Mock()
121        self.volume_one.connection.get_all_volumes.return_value = [self.volume_two]
122        retval = self.volume_one.update()
123        self.assertEqual(retval, "two_status")
124
125    def test_delete_calls_delete_volume(self):
126        self.volume_one.connection = mock.Mock()
127        self.volume_one.delete()
128        self.volume_one.connection.delete_volume.assert_called_with(
129            1,
130            dry_run=False
131        )
132
133    def test_attach_calls_attach_volume(self):
134        self.volume_one.connection = mock.Mock()
135        self.volume_one.attach("instance_id", "/dev/null")
136        self.volume_one.connection.attach_volume.assert_called_with(
137            1,
138            "instance_id",
139            "/dev/null",
140            dry_run=False
141        )
142
143    def test_detach_calls_detach_volume(self):
144        self.volume_one.connection = mock.Mock()
145        self.volume_one.detach()
146        self.volume_one.connection.detach_volume.assert_called_with(
147            1, 2, "/dev/null", False, dry_run=False)
148
149    def test_detach_with_no_attach_data(self):
150        self.volume_two.connection = mock.Mock()
151        self.volume_two.detach()
152        self.volume_two.connection.detach_volume.assert_called_with(
153            1, None, None, False, dry_run=False)
154
155    def test_detach_with_force_calls_detach_volume_with_force(self):
156        self.volume_one.connection = mock.Mock()
157        self.volume_one.detach(True)
158        self.volume_one.connection.detach_volume.assert_called_with(
159            1, 2, "/dev/null", True, dry_run=False)
160
161    def test_create_snapshot_calls_connection_create_snapshot(self):
162        self.volume_one.connection = mock.Mock()
163        self.volume_one.create_snapshot()
164        self.volume_one.connection.create_snapshot.assert_called_with(
165            1,
166            None,
167            dry_run=False
168        )
169
170    def test_create_snapshot_with_description(self):
171        self.volume_one.connection = mock.Mock()
172        self.volume_one.create_snapshot("some description")
173        self.volume_one.connection.create_snapshot.assert_called_with(
174            1,
175            "some description",
176            dry_run=False
177        )
178
179    def test_volume_state_returns_status(self):
180        retval = self.volume_one.volume_state()
181        self.assertEqual(retval, "one_status")
182
183    def test_attachment_state_returns_state(self):
184        retval = self.volume_one.attachment_state()
185        self.assertEqual(retval, "some status")
186
187    def test_attachment_state_no_attach_data_returns_None(self):
188        retval = self.volume_two.attachment_state()
189        self.assertEqual(retval, None)
190
191    def test_snapshots_returns_snapshots(self):
192        snapshot_one = Snapshot()
193        snapshot_one.volume_id = 1
194        snapshot_two = Snapshot()
195        snapshot_two.volume_id = 2
196
197        self.volume_one.connection = mock.Mock()
198        self.volume_one.connection.get_all_snapshots.return_value = [snapshot_one, snapshot_two]
199        retval = self.volume_one.snapshots()
200        self.assertEqual(retval, [snapshot_one])
201
202    def test_snapshots__with_owner_and_restorable_by(self):
203        self.volume_one.connection = mock.Mock()
204        self.volume_one.connection.get_all_snapshots.return_value = []
205        self.volume_one.snapshots("owner", "restorable_by")
206        self.volume_one.connection.get_all_snapshots.assert_called_with(
207            owner="owner", restorable_by="restorable_by", dry_run=False)
208
209
210class AttachmentSetTests(unittest.TestCase):
211    def check_that_attribute_has_been_set(self, name, value, attribute):
212        attachment_set = AttachmentSet()
213        attachment_set.endElement(name, value, None)
214        self.assertEqual(getattr(attachment_set, attribute), value)
215
216    def test_endElement_with_name_volumeId_sets_id(self):
217        return self.check_that_attribute_has_been_set("volumeId", "some value", "id")
218
219    def test_endElement_with_name_instanceId_sets_instance_id(self):
220        return self.check_that_attribute_has_been_set("instanceId", 1, "instance_id")
221
222    def test_endElement_with_name_status_sets_status(self):
223        return self.check_that_attribute_has_been_set("status", "some value", "status")
224
225    def test_endElement_with_name_attachTime_sets_attach_time(self):
226        return self.check_that_attribute_has_been_set("attachTime", 5, "attach_time")
227
228    def test_endElement_with_name_device_sets_device(self):
229        return self.check_that_attribute_has_been_set("device", "/dev/null", "device")
230
231    def test_endElement_with_other_name_sets_other_name_attribute(self):
232        return self.check_that_attribute_has_been_set("someName", "some value", "someName")
233
234
235class VolumeAttributeTests(unittest.TestCase):
236    def setUp(self):
237        self.volume_attribute = VolumeAttribute()
238        self.volume_attribute._key_name = "key_name"
239        self.volume_attribute.attrs = {"key_name": False}
240
241    def test_startElement_with_name_autoEnableIO_sets_key_name(self):
242        self.volume_attribute.startElement("autoEnableIO", None, None)
243        self.assertEqual(self.volume_attribute._key_name, "autoEnableIO")
244
245    def test_startElement_without_name_autoEnableIO_returns_None(self):
246        retval = self.volume_attribute.startElement("some name", None, None)
247        self.assertEqual(retval, None)
248
249    def test_endElement_with_name_value_and_value_true_sets_attrs_key_name_True(self):
250        self.volume_attribute.endElement("value", "true", None)
251        self.assertEqual(self.volume_attribute.attrs['key_name'], True)
252
253    def test_endElement_with_name_value_and_value_false_sets_attrs_key_name_False(self):
254        self.volume_attribute._key_name = "other_key_name"
255        self.volume_attribute.endElement("value", "false", None)
256        self.assertEqual(self.volume_attribute.attrs['other_key_name'], False)
257
258    def test_endElement_with_name_volumeId_sets_id(self):
259        self.volume_attribute.endElement("volumeId", "some_value", None)
260        self.assertEqual(self.volume_attribute.id, "some_value")
261
262    def test_endElement_with_other_name_sets_other_name_attribute(self):
263        self.volume_attribute.endElement("someName", "some value", None)
264        self.assertEqual(self.volume_attribute.someName, "some value")
265
266
267if __name__ == "__main__":
268    unittest.main()
269