1
# Copyright 2015 Red Hat, Inc.
3
# Licensed under the Apache License, Version 2.0 (the "License");
4
# you may not use this file except in compliance with the License.
5
# You may obtain a copy of the License at
7
# http://www.apache.org/licenses/LICENSE-2.0
8
# Unless required by applicable law or agreed to in writing, software
9
# distributed under the License is distributed on an "AS IS" BASIS,
10
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12
# See the License for the specific language governing permissions and
13
# limitations under the License.
17
from sahara import context
18
from sahara.db.templates import api as template_api
19
from sahara.db.templates import utils as u
20
from sahara.tests.unit.conductor import base
21
from sahara.tests.unit.db.templates import common as c
24
class Config(c.Config):
25
def __init__(self, option_values={}):
26
if "name" not in option_values:
27
option_values["name"] = "delete"
28
super(Config, self).__init__(option_values)
31
class TemplateDeleteTestCase(base.ConductorManagerTestCase):
33
super(TemplateDeleteTestCase, self).setUp()
34
self.logger = c.Logger()
35
template_api.set_logger(self.logger)
37
def test_node_group_template_delete_by_id(self):
38
self.logger.clear_log()
40
t = self.api.node_group_template_create(ctx, c.SAMPLE_NGT)
42
option_values = {"tenant_id": t["tenant_id"],
44
template_api.set_conf(Config(option_values))
46
template_api.do_node_group_template_delete_by_id()
47
msg = 'Deleted node group template {info}'.format(
48
info=u.name_and_id(t))
49
self.assertIn(msg, self.logger.infos)
51
t = self.api.node_group_template_get(ctx, t["id"])
54
def test_node_group_template_delete_by_id_skipped(self):
55
self.logger.clear_log()
57
template_values = copy.copy(c.SAMPLE_NGT)
58
template_values["is_default"] = False
59
t = self.api.node_group_template_create(ctx, template_values)
61
option_values = {"tenant_id": t["tenant_id"],
63
template_api.set_conf(Config(option_values))
65
template_api.do_node_group_template_delete_by_id()
66
msg = ("Deletion of node group template {info} skipped, "
67
"not a default template".format(info=u.name_and_id(t)))
68
self.assertIn(msg, self.logger.warnings)
70
t = self.api.node_group_template_get(ctx, t["id"])
71
self.assertIsNotNone(t)
73
def test_node_group_template_delete_bad_id(self):
74
self.logger.clear_log()
75
option_values = {"tenant_id": 1,
77
template_api.set_conf(Config(option_values))
78
template_api.do_node_group_template_delete_by_id()
79
msg = ("Deletion of node group template {id} failed, "
80
"no such template".format(id=option_values["id"]))
81
self.assertIn(msg, self.logger.warnings)
83
def test_node_group_template_delete_by_name(self):
84
self.logger.clear_log()
86
t = self.api.node_group_template_create(ctx, c.SAMPLE_NGT)
88
option_values = {"tenant_id": t["tenant_id"],
89
"template_name": t["name"]}
90
template_api.set_conf(Config(option_values))
92
template_api.do_node_group_template_delete()
93
msg = 'Deleted node group template {info}'.format(
94
info=u.name_and_id(t))
95
self.assertIn(msg, self.logger.infos)
97
t = self.api.node_group_template_get(ctx, t["id"])
100
def test_node_group_template_delete_by_name_skipped(self):
101
self.logger.clear_log()
103
template_values = copy.copy(c.SAMPLE_NGT)
104
template_values["is_default"] = False
105
t = self.api.node_group_template_create(ctx, template_values)
107
option_values = {"tenant_id": t["tenant_id"],
108
"template_name": t["name"]}
109
template_api.set_conf(Config(option_values))
111
template_api.do_node_group_template_delete()
112
msg = ("Deletion of node group template {name} failed, "
113
"no such template".format(name=t["name"]))
114
self.assertIn(msg, self.logger.warnings)
116
t = self.api.node_group_template_get(ctx, t["id"])
117
self.assertIsNotNone(t)
119
def test_node_group_template_delete_in_use(self):
120
self.logger.clear_log()
122
t = self.api.node_group_template_create(ctx, c.SAMPLE_NGT)
124
# Make a cluster that references the node group template
125
cluster_values = copy.deepcopy(c.SAMPLE_CLUSTER)
126
cluster_values["node_groups"][0]["node_group_template_id"] = t["id"]
127
cl = self.api.cluster_create(ctx, cluster_values)
129
# Make a cluster template that references the node group template
130
cluster_temp_values = copy.deepcopy(c.SAMPLE_CLT)
131
cluster_temp_values["node_groups"] = cluster_values["node_groups"]
132
clt = self.api.cluster_template_create(ctx, cluster_temp_values)
134
# Set up the expected messages
135
msgs = ["Node group template {info} in use "
136
"by clusters {clusters}".format(
137
info=u.name_and_id(t), clusters=[cl["name"]])]
139
msgs += ["Node group template {info} in use "
140
"by cluster templates {cluster_temps}".format(
141
info=u.name_and_id(t), cluster_temps=[clt["name"]])]
143
msgs += ["Deletion of node group template {info} failed".format(
144
info=u.name_and_id(t))]
146
# Check delete by name
147
option_values = {"tenant_id": t["tenant_id"],
148
"template_name": t["name"]}
149
template_api.set_conf(Config(option_values))
150
template_api.do_node_group_template_delete()
152
self.assertIn(msg, self.logger.warnings)
153
self.logger.clear_log()
155
# Check again with delete by id
156
option_values = {"tenant_id": t["tenant_id"],
158
template_api.set_conf(Config(option_values))
159
template_api.do_node_group_template_delete_by_id()
161
self.assertIn(msg, self.logger.warnings)
162
self.logger.clear_log()
164
def test_cluster_template_delete_by_id(self):
165
self.logger.clear_log()
167
t = self.api.cluster_template_create(ctx, c.SAMPLE_CLT)
169
option_values = {"tenant_id": t["tenant_id"],
171
template_api.set_conf(Config(option_values))
173
template_api.do_cluster_template_delete_by_id()
174
msg = 'Deleted cluster template {info}'.format(
175
info=u.name_and_id(t))
176
self.assertIn(msg, self.logger.infos)
178
t = self.api.cluster_template_get(ctx, t["id"])
181
def test_cluster_template_delete_by_id_skipped(self):
182
self.logger.clear_log()
184
template_values = copy.copy(c.SAMPLE_CLT)
185
template_values["is_default"] = False
186
t = self.api.cluster_template_create(ctx, template_values)
188
option_values = {"tenant_id": t["tenant_id"],
190
template_api.set_conf(Config(option_values))
191
template_api.do_cluster_template_delete_by_id()
192
msg = ("Deletion of cluster template {info} skipped, "
193
"not a default template".format(info=u.name_and_id(t)))
194
self.assertIn(msg, self.logger.warnings)
196
t = self.api.cluster_template_get(ctx, t["id"])
197
self.assertIsNotNone(t)
199
def test_cluster_template_delete_bad_id(self):
200
self.logger.clear_log()
201
option_values = {"tenant_id": 1,
203
template_api.set_conf(Config(option_values))
204
template_api.do_cluster_template_delete_by_id()
205
msg = ("Deletion of cluster template {id} failed, "
206
"no such template".format(id=option_values["id"]))
207
self.assertIn(msg, self.logger.warnings)
209
def test_cluster_template_delete_by_name(self):
210
self.logger.clear_log()
212
t = self.api.cluster_template_create(ctx, c.SAMPLE_NGT)
214
option_values = {"tenant_id": t["tenant_id"],
215
"template_name": t["name"]}
216
template_api.set_conf(Config(option_values))
218
template_api.do_cluster_template_delete()
219
msg = 'Deleted cluster template {info}'.format(
220
info=u.name_and_id(t))
221
self.assertIn(msg, self.logger.infos)
223
t = self.api.cluster_template_get(ctx, t["id"])
226
def test_cluster_template_delete_by_name_skipped(self):
227
self.logger.clear_log()
229
template_values = copy.copy(c.SAMPLE_NGT)
230
template_values["is_default"] = False
231
t = self.api.cluster_template_create(ctx, template_values)
233
option_values = {"tenant_id": t["tenant_id"],
234
"template_name": t["name"]}
235
template_api.set_conf(Config(option_values))
237
template_api.do_cluster_template_delete()
238
msg = ("Deletion of cluster template {name} failed, "
239
"no such template".format(name=t["name"]))
240
self.assertIn(msg, self.logger.warnings)
242
t = self.api.cluster_template_get(ctx, t["id"])
243
self.assertIsNotNone(t)
245
def test_cluster_template_delete_in_use(self):
246
self.logger.clear_log()
248
t = self.api.cluster_template_create(ctx, c.SAMPLE_CLT)
250
# Make a cluster that references the cluster template
251
cluster_values = copy.deepcopy(c.SAMPLE_CLUSTER)
252
cluster_values["cluster_template_id"] = t["id"]
253
del cluster_values["node_groups"]
254
cl = self.api.cluster_create(ctx, cluster_values)
256
# Set up the expected messages
257
msgs = ["Cluster template {info} in use "
258
"by clusters {clusters}".format(
259
info=u.name_and_id(t), clusters=[cl["name"]])]
261
msgs += ["Deletion of cluster template {info} failed".format(
262
info=u.name_and_id(t))]
264
# Check delete by name
265
option_values = {"tenant_id": t["tenant_id"],
266
"template_name": t["name"]}
267
template_api.set_conf(Config(option_values))
268
template_api.do_cluster_template_delete()
270
self.assertIn(msg, self.logger.warnings)
271
self.logger.clear_log()
273
# Check again with delete by id
274
option_values = {"tenant_id": t["tenant_id"],
276
template_api.set_conf(Config(option_values))
277
template_api.do_cluster_template_delete_by_id()
279
self.assertIn(msg, self.logger.warnings)
280
self.logger.clear_log()
282
def _make_templates(self, ctx, name, plugin_name, plugin_version):
283
# Make a node group template
284
values = copy.copy(c.SAMPLE_NGT)
285
values["name"] = "ngt_" + name
286
values["plugin_name"] = plugin_name
287
values["hadoop_version"] = plugin_version
288
ngt = self.api.node_group_template_create(ctx, values)
290
# Make a cluster template that references the node group template
291
values = copy.deepcopy(c.SAMPLE_CLT)
292
values["name"] = "clt_" + name
293
values["plugin_name"] = plugin_name
294
values["hadoop_version"] = plugin_version
295
values["node_groups"][0]["node_group_template_id"] = ngt["id"]
296
clt = self.api.cluster_template_create(ctx, values)
300
def test_do_delete(self):
301
self.logger.clear_log()
304
# Make some plugins to delete
305
ngt, clt = self._make_templates(ctx, "first", "plugin", "v1")
307
# Make some more for the same plugin, different version
308
ngt2, clt2 = self._make_templates(ctx, "second", "plugin", "v2")
310
# Make another set for a different plugin, overlapping version
311
safe_ngt, safe_clt = self._make_templates(ctx, "third", "plugin2",
314
# Run a delete by plugin name/version for the first set
315
option_values = {"tenant_id": ngt["tenant_id"],
316
"plugin_name": [ngt["plugin_name"]],
317
"plugin_version": [ngt["hadoop_version"]]}
318
template_api.set_conf(Config(option_values))
320
# Should delete clt and then ngt, check for messages in order
321
template_api.do_delete()
322
msgs = ["Deleted cluster template {info}".format(
323
info=u.name_and_id(clt))]
324
msgs += ["Deleted node group template {info}".format(
325
info=u.name_and_id(ngt))]
327
self.assertEqual(msgs, self.logger.infos)
328
self.assertIsNone(self.api.node_group_template_get(ctx, ngt["id"]))
329
self.assertIsNone(self.api.cluster_template_get(ctx, clt["id"]))
331
# Make sure the other templates are still there
332
self.assertIsNotNone(self.api.node_group_template_get(ctx,
334
self.assertIsNotNone(self.api.cluster_template_get(ctx,
336
self.assertIsNotNone(self.api.node_group_template_get(ctx,
338
self.assertIsNotNone(self.api.cluster_template_get(ctx,
341
# Run delete again for the plugin but with no version specified
342
self.logger.clear_log()
343
option_values = {"tenant_id": ngt2["tenant_id"],
344
"plugin_name": [ngt2["plugin_name"]],
345
"plugin_version": None}
346
template_api.set_conf(Config(option_values))
348
# Should delete clt2 and then ngt2, check for messages in order
349
template_api.do_delete()
350
msgs = ["Deleted cluster template {info}".format(
351
info=u.name_and_id(clt2))]
352
msgs += ["Deleted node group template {info}".format(
353
info=u.name_and_id(ngt2))]
355
self.assertEqual(msgs, self.logger.infos)
356
self.assertIsNone(self.api.node_group_template_get(ctx, ngt2["id"]))
357
self.assertIsNone(self.api.cluster_template_get(ctx, clt2["id"]))
359
# Make sure the other templates are still there
360
self.assertIsNotNone(self.api.node_group_template_get(ctx,
362
self.assertIsNotNone(self.api.cluster_template_get(ctx,