1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
import random
import time
from functools import partial
from tests.compat import unittest
from boto.beanstalk.wrapper import Layer1Wrapper
import boto.beanstalk.response as response
class BasicSuite(unittest.TestCase):
def setUp(self):
self.random_id = str(random.randint(1, 1000000))
self.app_name = 'app-' + self.random_id
self.app_version = 'version-' + self.random_id
self.template = 'template-' + self.random_id
self.environment = 'environment-' + self.random_id
self.beanstalk = Layer1Wrapper()
class MiscSuite(BasicSuite):
def test_check_dns_availability(self):
result = self.beanstalk.check_dns_availability('amazon')
self.assertIsInstance(result, response.CheckDNSAvailabilityResponse,
'incorrect response object returned')
self.assertFalse(result.available)
class TestApplicationObjects(BasicSuite):
def create_application(self):
# This method is used for any API calls that require an application
# object. This also adds a cleanup step to automatically delete the
# app when the test is finished. No assertions are performed
# here. If you want to validate create_application, don't use this
# method.
self.beanstalk.create_application(application_name=self.app_name)
self.addCleanup(partial(self.beanstalk.delete_application,
application_name=self.app_name))
def test_create_delete_application_version(self):
# This will create an app, create an app version, delete the app
# version, and delete the app. For each API call we check that the
# return type is what we expect and that a few attributes have the
# correct values.
app_result = self.beanstalk.create_application(application_name=self.app_name)
self.assertIsInstance(app_result, response.CreateApplicationResponse)
self.assertEqual(app_result.application.application_name, self.app_name)
version_result = self.beanstalk.create_application_version(
application_name=self.app_name, version_label=self.app_version)
self.assertIsInstance(version_result, response.CreateApplicationVersionResponse)
self.assertEqual(version_result.application_version.version_label,
self.app_version)
result = self.beanstalk.delete_application_version(
application_name=self.app_name, version_label=self.app_version)
self.assertIsInstance(result, response.DeleteApplicationVersionResponse)
result = self.beanstalk.delete_application(
application_name=self.app_name
)
self.assertIsInstance(result, response.DeleteApplicationResponse)
def test_create_configuration_template(self):
self.create_application()
result = self.beanstalk.create_configuration_template(
application_name=self.app_name, template_name=self.template,
solution_stack_name='32bit Amazon Linux running Tomcat 6')
self.assertIsInstance(
result, response.CreateConfigurationTemplateResponse)
self.assertEqual(result.solution_stack_name,
'32bit Amazon Linux running Tomcat 6')
def test_create_storage_location(self):
result = self.beanstalk.create_storage_location()
self.assertIsInstance(result, response.CreateStorageLocationResponse)
def test_update_application(self):
self.create_application()
result = self.beanstalk.update_application(application_name=self.app_name)
self.assertIsInstance(result, response.UpdateApplicationResponse)
def test_update_application_version(self):
self.create_application()
self.beanstalk.create_application_version(
application_name=self.app_name, version_label=self.app_version)
result = self.beanstalk.update_application_version(
application_name=self.app_name, version_label=self.app_version)
self.assertIsInstance(
result, response.UpdateApplicationVersionResponse)
class GetSuite(BasicSuite):
def test_describe_applications(self):
result = self.beanstalk.describe_applications()
self.assertIsInstance(result, response.DescribeApplicationsResponse)
def test_describe_application_versions(self):
result = self.beanstalk.describe_application_versions()
self.assertIsInstance(result,
response.DescribeApplicationVersionsResponse)
def test_describe_configuration_options(self):
result = self.beanstalk.describe_configuration_options()
self.assertIsInstance(result,
response.DescribeConfigurationOptionsResponse)
def test_12_describe_environments(self):
result = self.beanstalk.describe_environments()
self.assertIsInstance(
result, response.DescribeEnvironmentsResponse)
def test_14_describe_events(self):
result = self.beanstalk.describe_events()
self.assertIsInstance(result, response.DescribeEventsResponse)
def test_15_list_available_solution_stacks(self):
result = self.beanstalk.list_available_solution_stacks()
self.assertIsInstance(
result, response.ListAvailableSolutionStacksResponse)
self.assertIn('32bit Amazon Linux running Tomcat 6',
result.solution_stacks)
class TestsWithEnvironment(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.random_id = str(random.randint(1, 1000000))
cls.app_name = 'app-' + cls.random_id
cls.environment = 'environment-' + cls.random_id
cls.template = 'template-' + cls.random_id
cls.beanstalk = Layer1Wrapper()
cls.beanstalk.create_application(application_name=cls.app_name)
cls.beanstalk.create_configuration_template(
application_name=cls.app_name, template_name=cls.template,
solution_stack_name='32bit Amazon Linux running Tomcat 6')
cls.app_version = 'version-' + cls.random_id
cls.beanstalk.create_application_version(
application_name=cls.app_name, version_label=cls.app_version)
cls.beanstalk.create_environment(cls.app_name, cls.environment,
template_name=cls.template)
cls.wait_for_env(cls.environment)
@classmethod
def tearDownClass(cls):
cls.beanstalk.delete_application(application_name=cls.app_name,
terminate_env_by_force=True)
cls.wait_for_env(cls.environment, 'Terminated')
@classmethod
def wait_for_env(cls, env_name, status='Ready'):
while not cls.env_ready(env_name, status):
time.sleep(15)
@classmethod
def env_ready(cls, env_name, desired_status):
result = cls.beanstalk.describe_environments(
application_name=cls.app_name, environment_names=env_name)
status = result.environments[0].status
return status == desired_status
def test_describe_environment_resources(self):
result = self.beanstalk.describe_environment_resources(
environment_name=self.environment)
self.assertIsInstance(
result, response.DescribeEnvironmentResourcesResponse)
def test_describe_configuration_settings(self):
result = self.beanstalk.describe_configuration_settings(
application_name=self.app_name, environment_name=self.environment)
self.assertIsInstance(
result, response.DescribeConfigurationSettingsResponse)
def test_request_environment_info(self):
result = self.beanstalk.request_environment_info(
environment_name=self.environment, info_type='tail')
self.assertIsInstance(result, response.RequestEnvironmentInfoResponse)
self.wait_for_env(self.environment)
result = self.beanstalk.retrieve_environment_info(
environment_name=self.environment, info_type='tail')
self.assertIsInstance(result, response.RetrieveEnvironmentInfoResponse)
def test_rebuild_environment(self):
result = self.beanstalk.rebuild_environment(
environment_name=self.environment)
self.assertIsInstance(result, response.RebuildEnvironmentResponse)
self.wait_for_env(self.environment)
def test_restart_app_server(self):
result = self.beanstalk.restart_app_server(
environment_name=self.environment)
self.assertIsInstance(result, response.RestartAppServerResponse)
self.wait_for_env(self.environment)
def test_update_configuration_template(self):
result = self.beanstalk.update_configuration_template(
application_name=self.app_name, template_name=self.template)
self.assertIsInstance(
result, response.UpdateConfigurationTemplateResponse)
def test_update_environment(self):
result = self.beanstalk.update_environment(
environment_name=self.environment)
self.assertIsInstance(result, response.UpdateEnvironmentResponse)
self.wait_for_env(self.environment)
if __name__ == '__main__':
unittest.main()
|
