openstack
/
fuel-web
Code Issues Proposed changes

Don't use self.env.clusters[0] in tests where possible 

Since self.env.create always return db object now,
we can use this returned value instead of
self.env.clusters list.

It's a refactoring, so no bug or blueprint.

Change-Id: If7c84cb7124bcf08ef5ff110542012564190fae1
This commit is contained in:
Dmitry Guryanov 2016-04-19 18:07:31 +03:00
parent 93eb8fec2a
commit 9eeaa679d1
74 changed files with 434 additions and 659 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
nailgun/nailgun/extensions/cluster_upgrade/tests/test_handlers.py
View File

@ -77,12 +77,10 @@ class TestNodeReassignHandler(base.BaseIntegrationTest):
@mock.patch('nailgun.task.task.rpc.cast')
def test_node_reassign_handler(self, mcast):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'api': False},
nodes_kwargs=[{'status': consts.NODE_STATUSES.ready}])
self.env.create_cluster()
cluster = self.env.clusters[0]
seed_cluster = self.env.clusters[1]
seed_cluster = self.env.create_cluster()
node_id = cluster.nodes[0]['id']
resp = self.app.post(
@ -144,9 +142,7 @@ class TestNodeReassignHandler(base.BaseIntegrationTest):
self.assertEqual(node.roles, ['compute'])
def test_node_reassign_handler_no_node(self):
self.env.create_cluster()
cluster = self.env.clusters[0]
cluster = self.env.create_cluster()
resp = self.app.post(
reverse('NodeReassignHandler',
@ -159,10 +155,9 @@ class TestNodeReassignHandler(base.BaseIntegrationTest):
resp.json_body['message'])
def test_node_reassing_handler_wrong_status(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'api': False},
nodes_kwargs=[{'status': 'discover'}])
cluster = self.env.clusters[0]
resp = self.app.post(
reverse('NodeReassignHandler',
@ -175,11 +170,10 @@ class TestNodeReassignHandler(base.BaseIntegrationTest):
"^Node should be in one of statuses:")
def test_node_reassing_handler_wrong_error_type(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'api': False},
nodes_kwargs=[{'status': 'error',
'error_type': 'provision'}])
cluster = self.env.clusters[0]
resp = self.app.post(
reverse('NodeReassignHandler',
@ -192,10 +186,9 @@ class TestNodeReassignHandler(base.BaseIntegrationTest):
"^Node should be in error state")
def test_node_reassign_handler_to_the_same_cluster(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'api': False},
nodes_kwargs=[{'status': 'ready'}])
cluster = self.env.clusters[0]
cluster_id = cluster['id']
node_id = cluster.nodes[0]['id']

4
nailgun/nailgun/extensions/volume_manager/tests/test_node_disks.py
View File

@ -237,7 +237,7 @@ class TestNodeDisksHandlers(BaseIntegrationTest):
self.get_vgs(modified_roles_response))
def test_volumes_update_after_roles_assignment(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"cluster_id": None}
]
@ -255,7 +255,7 @@ class TestNodeDisksHandlers(BaseIntegrationTest):
self.app.post(
reverse(
'NodeAssignmentHandler',
kwargs={'cluster_id': self.env.clusters[0].id}
kwargs={'cluster_id': cluster.id}
),
jsonutils.dumps(assignment_data),
headers=self.default_headers

6
nailgun/nailgun/test/integration/test_action_logs.py
View File

@ -51,7 +51,7 @@ class TestActionLogs(BaseMasterNodeSettignsTest):
@fake_tasks()
def test_only_utc_datetime_used(self):
start_dt = datetime.datetime.utcnow()
self.env.create(
cluster = self.env.create(
api=True,
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True},
@ -62,7 +62,6 @@ class TestActionLogs(BaseMasterNodeSettignsTest):
task = self.env.launch_deployment()
self.assertEqual(task.status, consts.TASK_STATUSES.ready)
cluster = self.env.clusters[0]
self.app.delete(
reverse('ClusterHandler', kwargs={'obj_id': cluster.id}),
headers=self.default_headers
@ -80,7 +79,7 @@ class TestActionLogs(BaseMasterNodeSettignsTest):
@fake_tasks()
def test_all_action_logs_types_saved(self):
# Creating nailgun_tasks
self.env.create(
cluster = self.env.create(
api=True,
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True},
@ -92,7 +91,6 @@ class TestActionLogs(BaseMasterNodeSettignsTest):
self.assertEqual(task.status, consts.TASK_STATUSES.ready)
# Creating http_request
cluster = self.env.clusters[0]
self.app.delete(
reverse('ClusterHandler', kwargs={'obj_id': cluster.id}),
headers=self.default_headers

73
nailgun/nailgun/test/integration/test_attributes.py
View File

@ -30,7 +30,6 @@ class TestClusterAttributes(BaseIntegrationTest):
def test_attributes_creation(self):
cluster = self.env.create_cluster(api=True)
cluster_db = self.env.clusters[0]
resp = self.app.get(
reverse(
'ClusterAttributesHandler',
@ -42,13 +41,13 @@ class TestClusterAttributes(BaseIntegrationTest):
self._compare_editable(
release.attributes_metadata['editable'],
resp.json_body['editable'],
cluster_db
cluster
)
attrs = objects.Cluster.get_attributes(cluster_db)
attrs = objects.Cluster.get_attributes(cluster)
self._compare_generated(
release.attributes_metadata['generated'],
attrs['generated'],
cluster_db
cluster
)
def test_500_if_no_attributes(self):
@ -70,8 +69,8 @@ class TestClusterAttributes(BaseIntegrationTest):
self.assertEqual(500, resp.status_code)
def test_attributes_update_put(self):
cluster_id = self.env.create_cluster(api=True)['id']
cluster_db = self.env.clusters[0]
cluster = self.env.create_cluster(api=True)
cluster_id = cluster['id']
resp = self.app.get(
reverse(
'ClusterAttributesHandler',
@ -91,7 +90,7 @@ class TestClusterAttributes(BaseIntegrationTest):
headers=self.default_headers
)
self.assertEqual(200, resp.status_code)
attrs = objects.Cluster.get_editable_attributes(cluster_db)
attrs = objects.Cluster.get_editable_attributes(cluster)
self.assertEqual({'bar': None}, attrs["foo"])
attrs.pop('foo')
@ -123,19 +122,18 @@ class TestClusterAttributes(BaseIntegrationTest):
self.assertEqual(400, resp.status_code)
def test_attributes_update_patch(self):
cluster_id = self.env.create_cluster(api=True)['id']
cluster_db = self.env.clusters[0]
cluster = self.env.create_cluster(api=True)
resp = self.app.get(
reverse(
'ClusterAttributesHandler',
kwargs={'cluster_id': cluster_id}),
kwargs={'cluster_id': cluster['id']}),
headers=self.default_headers
)
self.assertEqual(200, resp.status_code)
resp = self.app.patch(
reverse(
'ClusterAttributesHandler',
kwargs={'cluster_id': cluster_id}),
kwargs={'cluster_id': cluster['id']}),
params=jsonutils.dumps({
'editable': {
'foo': {'bar': None}
@ -144,7 +142,7 @@ class TestClusterAttributes(BaseIntegrationTest):
headers=self.default_headers
)
self.assertEqual(200, resp.status_code)
attrs = objects.Cluster.get_editable_attributes(cluster_db)
attrs = objects.Cluster.get_editable_attributes(cluster)
self.assertEqual({'bar': None}, attrs["foo"])
attrs.pop('foo')
self.assertNotEqual(attrs, {})
@ -249,12 +247,11 @@ class TestClusterAttributes(BaseIntegrationTest):
self._compare_editable(
release.attributes_metadata['editable'],
resp.json_body['editable'],
self.env.clusters[0]
cluster
)
def test_get_last_deployed_attributes(self):
self.env.create_cluster(api=True)
cluster = self.env.clusters[-1]
cluster = self.env.create_cluster(api=True)
cluster_attrs = objects.Cluster.get_editable_attributes(
self.env.clusters[-1]
)
@ -291,7 +288,6 @@ class TestClusterAttributes(BaseIntegrationTest):
def test_attributes_set_defaults(self):
cluster = self.env.create_cluster(api=True)
cluster_db = self.env.clusters[0]
# Change editable attributes.
resp = self.app.put(
reverse(
@ -306,7 +302,7 @@ class TestClusterAttributes(BaseIntegrationTest):
expect_errors=True
)
self.assertEqual(200, resp.status_code, resp.body)
attrs = objects.Cluster.get_editable_attributes(cluster_db)
attrs = objects.Cluster.get_editable_attributes(cluster)
self.assertEqual({'bar': None}, attrs['foo'])
# Set attributes to defaults.
resp = self.app.put(
@ -322,7 +318,7 @@ class TestClusterAttributes(BaseIntegrationTest):
self._compare_editable(
release.attributes_metadata['editable'],
resp.json_body['editable'],
cluster_db
cluster
)
def test_attributes_merged_values(self):
@ -437,8 +433,7 @@ class TestClusterAttributes(BaseIntegrationTest):
AssertionError, self._compare_editable, r_attrs, c_attrs)
def test_editable_attributes_generators(self):
self.env.create_cluster(api=True)
cluster = self.env.clusters[0]
cluster = self.env.create_cluster(api=True)
editable = objects.Cluster.get_editable_attributes(cluster)
self.assertEqual(
editable["external_dns"]["dns_list"]["value"],
@ -450,8 +445,7 @@ class TestClusterAttributes(BaseIntegrationTest):
)
def test_workloads_collector_attributes(self):
self.env.create_cluster(api=True)
cluster = self.env.clusters[0]
cluster = self.env.create_cluster(api=True)
editable = objects.Cluster.get_editable_attributes(cluster)
self.assertEqual(
editable["workloads_collector"]["enabled"]["value"],
@ -498,11 +492,10 @@ class TestAlwaysEditable(BaseIntegrationTest):
def setUp(self):
super(TestAlwaysEditable, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={
'version': 'liberty-8.0',
'operating_system': consts.RELEASE_OS.centos})
self.cluster = self.env.clusters[0]
def _put(self, data, expect_code=200):
resp = self.app.put(
@ -538,10 +531,9 @@ class TestVmwareAttributes(BaseIntegrationTest):
def setUp(self):
super(TestVmwareAttributes, self).setUp()
self.cluster = self.env.create_cluster(api=True)
self.cluster_db = self.env.clusters[0]
def test_vmware_attributes_creation(self):
self._set_use_vcenter(self.cluster_db)
self._set_use_vcenter(self.cluster)
resp = self.app.get(
reverse(
@ -552,7 +544,7 @@ class TestVmwareAttributes(BaseIntegrationTest):
release = objects.Release.get_by_uid(self.cluster['release_id'])
self.assertEqual(200, resp.status_code)
attrs = objects.Cluster.get_vmware_attributes(self.cluster_db)
attrs = objects.Cluster.get_vmware_attributes(self.cluster)
# TODO(apopovych): use dictdiffer 0.3.0 to compare atttributes
# one-by-one
self.assertEqual(
@ -561,7 +553,7 @@ class TestVmwareAttributes(BaseIntegrationTest):
)
def test_vmware_attributes_update(self):
self._set_use_vcenter(self.cluster_db)
self._set_use_vcenter(self.cluster)
resp = self.app.put(
reverse(
@ -576,13 +568,13 @@ class TestVmwareAttributes(BaseIntegrationTest):
)
self.assertEqual(200, resp.status_code)
attrs = objects.Cluster.get_vmware_attributes(self.cluster_db)
attrs = objects.Cluster.get_vmware_attributes(self.cluster)
self.assertEqual('bar', attrs.editable.get('value', {}).get('foo'))
attrs.editable.get('value', {}).pop('foo')
self.assertEqual(attrs.editable.get('value'), {})
def test_vmware_attributes_update_with_invalid_json_format(self):
self._set_use_vcenter(self.cluster_db)
self._set_use_vcenter(self.cluster)
resp = self.app.put(
reverse(
@ -599,7 +591,7 @@ class TestVmwareAttributes(BaseIntegrationTest):
self.assertEqual(
"'editable' is a required property", resp.json_body["message"])
self._set_use_vcenter(self.cluster_db)
self._set_use_vcenter(self.cluster)
resp = self.app.put(
reverse(
@ -673,11 +665,11 @@ class TestVmwareAttributes(BaseIntegrationTest):
@patch('nailgun.db.sqlalchemy.models.Cluster.is_locked', return_value=True)
def test_vmware_attributes_update_for_locked_cluster_403(self, locked):
self._set_use_vcenter(self.cluster_db)
self._set_use_vcenter(self.cluster)
resp = self.app.put(
reverse(
'VmwareAttributesHandler',
kwargs={'cluster_id': self.cluster_db.id}),
kwargs={'cluster_id': self.cluster.id}),
params=jsonutils.dumps({
"editable": {
"value": {"foo": "bar"}
@ -694,7 +686,7 @@ class TestVmwareAttributes(BaseIntegrationTest):
@patch('nailgun.db.sqlalchemy.models.Cluster.is_locked', return_value=True)
def test_vmware_attributes_update_for_locked_cluster_200(
self, is_locked_mock, has_compute_mock):
self._set_use_vcenter(self.cluster_db)
self._set_use_vcenter(self.cluster)
params = {
"editable": {
"value": {"foo": "bar"}
@ -704,12 +696,12 @@ class TestVmwareAttributes(BaseIntegrationTest):
resp = self.app.put(
reverse(
'VmwareAttributesHandler',
kwargs={'cluster_id': self.cluster_db.id}),
kwargs={'cluster_id': self.cluster.id}),
params=jsonutils.dumps(params),
headers=self.default_headers
)
self.assertEqual(200, resp.status_code)
attrs = objects.Cluster.get_vmware_attributes(self.cluster_db)
attrs = objects.Cluster.get_vmware_attributes(self.cluster)
self.assertEqual('bar', attrs.editable.get('value', {}).get('foo'))
attrs.editable.get('value', {}).pop('foo')
self.assertEqual(attrs.editable.get('value'), {})
@ -725,11 +717,10 @@ class TestVmwareAttributesDefaults(BaseIntegrationTest):
def test_get_default_vmware_attributes(self):
cluster = self.env.create_cluster(api=True)
cluster_db = self.env.clusters[0]
cluster_attrs = objects.Cluster.get_editable_attributes(cluster_db)
cluster_attrs = objects.Cluster.get_editable_attributes(cluster)
cluster_attrs['common']['use_vcenter']['value'] = True
objects.Cluster.update_attributes(
cluster_db, {'editable': cluster_attrs})
cluster, {'editable': cluster_attrs})
resp = self.app.get(
reverse(
'VmwareAttributesDefaultsHandler',
@ -765,7 +756,7 @@ class TestAttributesWithPlugins(BaseIntegrationTest):
def setUp(self):
super(TestAttributesWithPlugins, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={
'operating_system': consts.RELEASE_OS.ubuntu,
'version': '2015.1.0-7.0',
@ -781,8 +772,6 @@ class TestAttributesWithPlugins(BaseIntegrationTest):
]
)
self.cluster = self.env.clusters[0]
self.plugin_data = {
'releases': [
{

18
nailgun/nailgun/test/integration/test_changes_model.py
View File

@ -93,8 +93,7 @@ class TestClusterChanges(BaseIntegrationTest):
def test_attributes_changing_adds_pending_changes(self):
cluster = self.env.create_cluster(api=True)
cluster_db = self.env.clusters[0]
objects.Cluster.clear_pending_changes(cluster_db)
objects.Cluster.clear_pending_changes(cluster)
all_changes = self.db.query(ClusterChanges).all()
self.assertEqual(len(all_changes), 0)
self.app.put(
@ -115,8 +114,7 @@ class TestClusterChanges(BaseIntegrationTest):
def test_default_attributes_adds_pending_changes(self):
cluster = self.env.create_cluster(api=True)
cluster_db = self.env.clusters[0]
objects.Cluster.clear_pending_changes(cluster_db)
objects.Cluster.clear_pending_changes(cluster)
all_changes = self.db.query(ClusterChanges).all()
self.assertEqual(len(all_changes), 0)
self.app.put(
@ -132,7 +130,7 @@ class TestClusterChanges(BaseIntegrationTest):
@fake_tasks(override_state={"progress": 100, "status": "ready"})
def test_successful_deployment_drops_all_changes(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"api": True, "pending_addition": True}
]
@ -140,9 +138,7 @@ class TestClusterChanges(BaseIntegrationTest):
supertask = self.env.launch_deployment()
self.assertEqual(supertask.status, consts.TASK_STATUSES.ready)
cluster_db = self.db.query(Cluster).get(
self.env.clusters[0].id
)
cluster_db = self.db.query(Cluster).get(cluster.id)
self.assertEqual(list(cluster_db.changes), [])
@fake_tasks(error="deployment", error_msg="Terrible error")
@ -178,7 +174,7 @@ class TestClusterChanges(BaseIntegrationTest):
@fake_tasks(override_state={"progress": 100, "status": "ready"})
def test_role_unassignment_drops_changes(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"pending_addition": True, "api": True}
]
@ -186,7 +182,7 @@ class TestClusterChanges(BaseIntegrationTest):
supertask = self.env.launch_deployment()
self.assertEqual(supertask.status, consts.TASK_STATUSES.ready)
new_node = self.env.create_node(
cluster_id=self.env.clusters[0].id,
cluster_id=cluster.id,
pending_addition=True,
api=True
)
@ -201,7 +197,7 @@ class TestClusterChanges(BaseIntegrationTest):
headers=self.default_headers
)
all_changes = self.db.query(ClusterChanges).filter_by(
cluster_id=self.env.clusters[0].id,
cluster_id=cluster.id,
node_id=new_node["id"]
).all()
self.assertEqual(all_changes, [])

9
nailgun/nailgun/test/integration/test_charset_issues.py
View File

@ -48,7 +48,7 @@ class TestCharsetIssues(BaseIntegrationTest):
@fake_tasks(fake_rpc=False)
def test_deletion_during_deployment(self, mock_rpc):
self.env.create(
cluster = self.env.create(
cluster_kwargs={
"name": u"Вася"
},
@ -56,11 +56,10 @@ class TestCharsetIssues(BaseIntegrationTest):
{"status": "ready", "pending_addition": True},
]
)
cluster_id = self.env.clusters[0].id
resp = self.app.put(
reverse(
'ClusterChangesHandler',
kwargs={'cluster_id': cluster_id}),
kwargs={'cluster_id': cluster.id}),
headers=self.default_headers
)
deploy_uuid = resp.json_body['uuid']
@ -73,7 +72,7 @@ class TestCharsetIssues(BaseIntegrationTest):
resp = self.app.delete(
reverse(
'ClusterHandler',
kwargs={'obj_id': cluster_id}),
kwargs={'obj_id': cluster.id}),
headers=self.default_headers
)
task_delete = self.db.query(models.Task).filter_by(
@ -86,5 +85,5 @@ class TestCharsetIssues(BaseIntegrationTest):
)
cluster = self.db.query(models.Cluster).filter_by(
id=cluster_id).first()
id=cluster.id).first()
self.assertIsNone(cluster)

12
nailgun/nailgun/test/integration/test_cluster.py
View File

@ -35,7 +35,7 @@ class TestCluster(BaseIntegrationTest):
self.assertIsNotNone(primary_node)
def test_adjust_nodes_lists_on_controller_removing(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller']},
{'pending_roles': ['controller']},
@ -44,7 +44,6 @@ class TestCluster(BaseIntegrationTest):
{'roles': ['compute']},
]
)
cluster = self.env.clusters[0]
controllers = filter(lambda x: 'controller' in x.all_roles,
cluster.nodes)
@ -77,12 +76,11 @@ class TestCluster(BaseIntegrationTest):
self.assertItemsEqual(controllers[1:], n_deploy)
def test_adjust_nodes_lists_on_controller_removing_no_cluster(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller']}
]
)
cluster = self.env.clusters[0]
for node in cluster.nodes:
self.assertIn('controller', node.all_roles)
@ -96,7 +94,7 @@ class TestCluster(BaseIntegrationTest):
@fake_tasks(override_state={'progress': 100,
'status': consts.TASK_STATUSES.ready})
def test_get_primary_node(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'pending_roles': ['controller'],
'pending_addition': True},
@ -108,7 +106,6 @@ class TestCluster(BaseIntegrationTest):
'pending_addition': True},
]
)
cluster = self.env.clusters[0]
# Checking no primary nodes before deployment
self.check_no_primary_node(
@ -124,14 +121,13 @@ class TestCluster(BaseIntegrationTest):
@fake_tasks(override_state={'progress': 100,
'status': consts.TASK_STATUSES.ready})
def test_get_primary_node_pending_deletion(self):
self.env.create(
cluster = self.env.create(
api=True,
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True},
{'roles': ['compute'], 'pending_addition': True}
]
)
cluster = self.env.clusters[0]
# Checking primary present
deploy = self.env.launch_deployment()

67
nailgun/nailgun/test/integration/test_cluster_changes_handler.py
View File

@ -38,7 +38,7 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_nova_deploy_cast_with_right_args(self, mocked_rpc):
self.env.create(
cluster_db = self.env.create(
release_kwargs={
'version': "2014.2-6.0"
},
@ -55,8 +55,6 @@ class TestHandlers(BaseIntegrationTest):
]
)
cluster_db = self.env.clusters[0]
common_attrs = {
'deployment_mode': consts.CLUSTER_MODES.ha_compact,
@ -392,7 +390,7 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_neutron_deploy_cast_with_right_args_for_5_1_1(self, mocked_rpc):
self.env.create(
cluster_db = self.env.create(
release_kwargs={
'version': "2014.1.3-5.1.1"
},
@ -412,7 +410,6 @@ class TestHandlers(BaseIntegrationTest):
]
)
cluster_db = self.env.clusters[0]
self.env.disable_task_deploy(cluster_db)
# This is here to work around the fact that we use the same fixture
@ -882,7 +879,7 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_neutron_deploy_cast_with_right_args_for_6_0(self, mocked_rpc):
self.env.create(
cluster_db = self.env.create(
release_kwargs={
'version': "2014.2-6.0"
},
@ -902,7 +899,6 @@ class TestHandlers(BaseIntegrationTest):
]
)
cluster_db = self.env.clusters[0]
self.env.disable_task_deploy(cluster_db)
# This is here to work around the fact that we use the same fixture
@ -1422,7 +1418,7 @@ class TestHandlers(BaseIntegrationTest):
@patch('nailgun.rpc.cast')
def test_deploy_multinode_neutron_gre_w_custom_public_ranges(self,
mocked_rpc):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'net_provider': 'neutron',
'net_segment_type': 'gre'},
nodes_kwargs=[{"pending_addition": True},
@ -1432,15 +1428,13 @@ class TestHandlers(BaseIntegrationTest):
{"pending_addition": True}]
)
net_data = self.env.neutron_networks_get(
self.env.clusters[0].id
).json_body
net_data = self.env.neutron_networks_get(cluster.id).json_body
pub = filter(lambda ng: ng['name'] == 'public',
net_data['networks'])[0]
pub.update({'ip_ranges': [['172.16.0.10', '172.16.0.13'],
['172.16.0.20', '172.16.0.22']]})
resp = self.env.neutron_networks_put(self.env.clusters[0].id, net_data)
resp = self.env.neutron_networks_put(cluster.id, net_data)
self.assertEqual(resp.status_code, 200)
self.env.launch_deployment()
@ -1466,7 +1460,7 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_deploy_ha_neutron_gre_w_custom_public_ranges(self, mocked_rpc):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'mode': consts.CLUSTER_MODES.ha_compact,
'net_provider': 'neutron',
'net_segment_type': 'gre'},
@ -1477,15 +1471,13 @@ class TestHandlers(BaseIntegrationTest):
{"pending_addition": True}]
)
net_data = self.env.neutron_networks_get(
self.env.clusters[0].id
).json_body
net_data = self.env.neutron_networks_get(cluster.id).json_body
pub = filter(lambda ng: ng['name'] == 'public',
net_data['networks'])[0]
pub.update({'ip_ranges': [['172.16.0.10', '172.16.0.13'],
['172.16.0.20', '172.16.0.22']]})
resp = self.env.neutron_networks_put(self.env.clusters[0].id, net_data)
resp = self.env.neutron_networks_put(cluster.id, net_data)
self.assertEqual(resp.status_code, 200)
self.env.launch_deployment()
@ -1509,16 +1501,14 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_deploy_neutron_gre_w_changed_public_cidr(self, mocked_rpc):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'net_provider': 'neutron',
'net_segment_type': 'gre'},
nodes_kwargs=[{"pending_addition": True},
{"pending_addition": True}]
)
net_data = self.env.neutron_networks_get(
self.env.clusters[0].id
).json_body
net_data = self.env.neutron_networks_get(cluster.id).json_body
pub = filter(lambda ng: ng['name'] == 'public',
net_data['networks'])[0]
pub.update({'ip_ranges': [['172.16.10.10', '172.16.10.122']],
@ -1527,7 +1517,7 @@ class TestHandlers(BaseIntegrationTest):
net_data['networking_parameters']['floating_ranges'] = \
[['172.16.10.130', '172.16.10.254']]
resp = self.env.neutron_networks_put(self.env.clusters[0].id, net_data)
resp = self.env.neutron_networks_put(cluster.id, net_data)
self.assertEqual(resp.status_code, 200)
self.env.launch_deployment()
@ -1546,7 +1536,7 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_deploy_neutron_error_not_enough_ip_addresses(self, mocked_rpc):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'net_provider': 'neutron',
'net_segment_type': 'gre'},
nodes_kwargs=[{"pending_addition": True},
@ -1554,14 +1544,12 @@ class TestHandlers(BaseIntegrationTest):
{"pending_addition": True}]
)
net_data = self.env.neutron_networks_get(
self.env.clusters[0].id
).json_body
net_data = self.env.neutron_networks_get(cluster.id).json_body
pub = filter(lambda ng: ng['name'] == 'public',
net_data['networks'])[0]
pub.update({'ip_ranges': [['172.16.0.10', '172.16.0.11']]})
resp = self.env.neutron_networks_put(self.env.clusters[0].id, net_data)
resp = self.env.neutron_networks_put(cluster.id, net_data)
self.assertEqual(resp.status_code, 200)
task = self.env.launch_deployment()
@ -1573,7 +1561,7 @@ class TestHandlers(BaseIntegrationTest):
'at least 3 IP addresses for the current environment.')
def test_occurs_error_not_enough_ip_addresses(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.nova_network,
},
@ -1582,8 +1570,6 @@ class TestHandlers(BaseIntegrationTest):
{'pending_addition': True},
{'pending_addition': True}])
cluster = self.env.clusters[0]
public_network = self.db.query(
NetworkGroup).filter_by(name='public').first()
@ -1668,16 +1654,16 @@ class TestHandlers(BaseIntegrationTest):
'or reduce Ceph replication factor in the Settings tab.')
def test_occurs_error_release_is_unavailable(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True}])
self.env.clusters[0].release.state = consts.RELEASE_STATES.unavailable
cluster.release.state = consts.RELEASE_STATES.unavailable
resp = self.app.put(
reverse(
'ClusterChangesHandler',
kwargs={'cluster_id': self.env.clusters[0].id}),
kwargs={'cluster_id': cluster.id}),
headers=self.default_headers,
expect_errors=True)
@ -1685,7 +1671,7 @@ class TestHandlers(BaseIntegrationTest):
self.assertRegexpMatches(resp.body, 'Release .* is unavailable')
def test_occurs_error_no_deployment_tasks_for_release(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True}],
release_kwargs={
@ -1696,7 +1682,7 @@ class TestHandlers(BaseIntegrationTest):
resp = self.app.put(
reverse(
'ClusterChangesHandler',
kwargs={'cluster_id': self.env.clusters[0].id}),
kwargs={'cluster_id': cluster.id}),
headers=self.default_headers,
expect_errors=True)
@ -1741,7 +1727,7 @@ class TestHandlers(BaseIntegrationTest):
"name": "eth1",
"current_speed": None}])
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{
'api': True,
@ -1752,24 +1738,23 @@ class TestHandlers(BaseIntegrationTest):
}
]
)
cluster_id = self.env.clusters[0].id
resp = self.env.neutron_networks_get(cluster_id)
resp = self.env.neutron_networks_get(cluster.id)
nets = resp.json_body
for net in nets["networks"]:
if net["name"] in ["management", ]:
net["vlan_start"] = None
self.env.neutron_networks_put(cluster_id, nets)
self.env.neutron_networks_put(cluster.id, nets)
supertask = self.env.launch_deployment()
self.assertEqual(supertask.status, consts.TASK_STATUSES.error)
def test_empty_cluster_deploy_error(self):
self.env.create(nodes_kwargs=[])
cluster = self.env.create(nodes_kwargs=[])
resp = self.app.put(
reverse(
'ClusterChangesHandler',
kwargs={'cluster_id': self.env.clusters[0].id}
kwargs={'cluster_id': cluster.id}
),
headers=self.default_headers,
expect_errors=True

17
nailgun/nailgun/test/integration/test_cluster_handler.py
View File

@ -155,17 +155,16 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks()
def test_cluster_deletion(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"pending_addition": True},
{"status": "ready"}])
cluster_id = self.env.clusters[0].id
resp = self.delete(cluster_id)
resp = self.delete(cluster.id)
self.assertEqual(resp.status_code, 202)
self.assertIsNone(self.db.query(Cluster).get(cluster_id))
self.assertIsNone(self.db.query(Cluster).get(cluster.id))
# Nodes should be in discover status
self.assertEqual(self.db.query(Node).count(), 2)
@ -179,17 +178,16 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks(recover_offline_nodes=False)
def test_cluster_deletion_with_offline_nodes(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{'pending_addition': True},
{'online': False, 'status': 'ready'}])
cluster_id = self.env.clusters[0].id
resp = self.delete(cluster_id)
resp = self.delete(cluster.id)
self.assertEqual(resp.status_code, 202)
self.assertIsNone(self.db.query(Cluster).get(cluster_id))
self.assertIsNone(self.db.query(Cluster).get(cluster.id))
self.assertEqual(self.db.query(Node).count(), 1)
node = self.db.query(Node).first()
@ -208,11 +206,10 @@ class TestHandlers(BaseIntegrationTest):
self.assertEqual(ngs, [])
def test_cluster_generated_data_handler(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'pending_addition': True},
{'online': False, 'status': 'ready'}])
cluster = self.env.clusters[0]
get_resp = self.app.get(
reverse('ClusterGeneratedData',
kwargs={'cluster_id': cluster.id}),

4
nailgun/nailgun/test/integration/test_cluster_plugin_links_collection_handler.py
View File

@ -56,7 +56,7 @@ class TestAssignmentHandlers(BaseIntegrationTest):
)
self.assertEqual(201, resp.status_code)
plugin_link = self.env.clusters[0].plugin_links[0]
plugin_link = self.cluster.plugin_links[0]
self.assertEqual(self.link_data['title'], plugin_link.title)
self.assertEqual(self.link_data['url'], plugin_link.url)
self.assertEqual(self.link_data['hidden'], plugin_link.hidden)
@ -79,4 +79,4 @@ class TestAssignmentHandlers(BaseIntegrationTest):
expect_errors=True
)
self.assertEqual(400, resp.status_code)
self.assertItemsEqual([], self.env.clusters[0].plugin_links)
self.assertItemsEqual([], self.cluster.plugin_links)

3
nailgun/nailgun/test/integration/test_cluster_roles_handler.py
View File

@ -47,8 +47,7 @@ class TestClusterRolesHandler(base.BaseTestCase):
def setUp(self):
super(TestClusterRolesHandler, self).setUp()
self.env.create_cluster(api=False)
self.cluster = self.env.clusters[0]
self.cluster = self.env.create_cluster(api=False)
self.expected_roles_data = self.cluster.release.roles_metadata
self.expected_volumes_data = \
self.cluster.release.volumes_metadata['volumes_roles_mapping']

9
nailgun/nailgun/test/integration/test_graph_related_handlers.py
View File

@ -33,11 +33,10 @@ class BaseGraphTasksTests(BaseIntegrationTest):
def setUp(self):
super(BaseGraphTasksTests, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'roles': ['test-controller'], 'pending_addition': True},
])
self.cluster = self.env.clusters[0]
def get_correct_tasks(self):
yaml_tasks = """
@ -644,9 +643,8 @@ class TestTaskDeployGraph(BaseGraphTasksTests):
def setUp(self):
super(TestTaskDeployGraph, self).setUp()
self.env.create()
self.cluster = self.env.create()
self.cluster = self.env.clusters[0]
self.tasks = [
{'id': 'pre_deployment', 'type': 'stage'},
{'id': 'deploy', 'type': 'stage'},
@ -835,8 +833,7 @@ class TestTaskDeployCustomGraph(BaseGraphTasksTests):
def setUp(self):
super(TestTaskDeployCustomGraph, self).setUp()
self.env.create()
self.cluster = self.env.clusters[-1]
self.cluster = self.env.create()
def test_get_custom_tasks(self):
objects.DeploymentGraph.create_for_model(

18
nailgun/nailgun/test/integration/test_mongo_nodes.py
View File

@ -35,15 +35,14 @@ class TestMongoNodes(base.BaseTestCase):
return attr_meta
def test_get_zero_mongo_nodes(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[{}]
)
cluster = self.env.clusters[0]
nodes = objects.Cluster.get_nodes_by_role(cluster, 'mongo')
self.assertEqual(len(nodes), 0)
def test_get_mongo_nodes(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'pending_roles': ['mongo'],
'status': 'discover',
@ -53,12 +52,11 @@ class TestMongoNodes(base.BaseTestCase):
'pending_addition': True}
]
)
cluster = self.env.clusters[0]
nodes = objects.Cluster.get_nodes_by_role(cluster, 'mongo')
self.assertEqual(len(nodes), 2)
def test_mongo_node_with_ext_mongo(self):
self.env.create(
cluster = self.env.create(
release_kwargs={
'attributes_metadata': self.get_custom_meta(True, True)},
nodes_kwargs=[
@ -67,36 +65,33 @@ class TestMongoNodes(base.BaseTestCase):
'pending_addition': True}
]
)
cluster = self.env.clusters[0]
task = Task(name=TASK_NAMES.deploy, cluster=cluster)
self.assertRaises(errors.ExtMongoCheckerError,
CheckBeforeDeploymentTask._check_mongo_nodes,
task)
def test_ext_mongo_without_mongo_node(self):
self.env.create(
cluster = self.env.create(
release_kwargs={
'attributes_metadata': self.get_custom_meta(True, True)},
nodes_kwargs=[]
)
cluster = self.env.clusters[0]
task = Task(name=TASK_NAMES.deploy, cluster=cluster)
CheckBeforeDeploymentTask._check_mongo_nodes(task)
def test_without_any_mongo(self):
self.env.create(
cluster = self.env.create(
release_kwargs={
'attributes_metadata': self.get_custom_meta(True, False)},
nodes_kwargs=[]
)
cluster = self.env.clusters[0]
task = Task(name=TASK_NAMES.deploy, cluster=cluster)
self.assertRaises(errors.MongoNodesCheckError,
CheckBeforeDeploymentTask._check_mongo_nodes,
task)
def test_mongo_node_without_ext_mongo(self):
self.env.create(
cluster = self.env.create(
release_kwargs={
'attributes_metadata': self.get_custom_meta(True, False)},
nodes_kwargs=[
@ -105,6 +100,5 @@ class TestMongoNodes(base.BaseTestCase):
'pending_addition': True}
]
)
cluster = self.env.clusters[0]
task = Task(name=TASK_NAMES.deploy, cluster=cluster)
CheckBeforeDeploymentTask._check_mongo_nodes(task)

3
nailgun/nailgun/test/integration/test_network_configuration.py
View File

@ -255,7 +255,7 @@ class TestNeutronNetworkConfigurationHandler(BaseIntegrationTest):
def setUp(self):
super(TestNeutronNetworkConfigurationHandler, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={'version': '1111-8.0'},
cluster_kwargs={
'api': True,
@ -267,7 +267,6 @@ class TestNeutronNetworkConfigurationHandler(BaseIntegrationTest):
# node group which network VIP must be allocated in)
nodes_kwargs=[{'roles': ['controller']}]
)
self.cluster = self.env.clusters[0]
def test_get_request_should_return_net_provider_segment_and_networks(self):
resp = self.env.neutron_networks_get(self.cluster.id)

4
nailgun/nailgun/test/integration/test_network_manager.py
View File

@ -58,7 +58,7 @@ class TestNetworkManager(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_assign_ips(self, mocked_rpc):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"pending_addition": True, "api": True},
@ -75,7 +75,7 @@ class TestNetworkManager(BaseIntegrationTest):
management_net = self.db.query(NetworkGroup).filter(
NetworkGroup.group_id ==
objects.Cluster.get_default_group(self.env.clusters[0]).id
objects.Cluster.get_default_group(cluster).id
).filter_by(
name=consts.NETWORKS.management
).first()

47
nailgun/nailgun/test/integration/test_network_models.py
View File

@ -53,7 +53,7 @@ class TestNetworkModels(BaseIntegrationTest):
}
def create_env_using_statuses(self, cluster_status, node_status):
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
'net_segment_type': consts.NEUTRON_SEGMENT_TYPES.gre,
@ -63,27 +63,28 @@ class TestNetworkModels(BaseIntegrationTest):
{'pending_addition': False, 'status': node_status},
{'pending_addition': False, 'status': node_status},
{'pending_deletion': False, 'status': node_status}])
return cluster
def test_cluster_locking_during_deployment(self):
self.create_env_using_statuses(consts.CLUSTER_STATUSES.deployment,
consts.NODE_STATUSES.deploying)
cluster = self.create_env_using_statuses(
consts.CLUSTER_STATUSES.deployment,
consts.NODE_STATUSES.deploying)
test_nets = self.env.neutron_networks_get(
self.env.clusters[0].id).json_body
test_nets = self.env.neutron_networks_get(cluster.id).json_body
resp_nova_net = self.env.nova_networks_put(
self.env.clusters[0].id,
cluster.id,
test_nets,
expect_errors=True)
resp_neutron_net = self.env.neutron_networks_put(
self.env.clusters[0].id,
cluster.id,
test_nets,
expect_errors=True)
resp_cluster = self.app.put(
reverse('ClusterAttributesHandler',
kwargs={'cluster_id': self.env.clusters[0].id}),
kwargs={'cluster_id': cluster.id}),
jsonutils.dumps({
'editable': {
"foo": {"bar": None}
@ -94,7 +95,7 @@ class TestNetworkModels(BaseIntegrationTest):
resp_cluster_get = self.app.get(
reverse('ClusterHandler',
kwargs={'obj_id': self.env.clusters[0].id}),
kwargs={'obj_id': cluster.id}),
headers=self.default_headers)
self.assertTrue(resp_cluster_get.json_body['is_locked'])
@ -105,11 +106,11 @@ class TestNetworkModels(BaseIntegrationTest):
self.assertEqual(resp_cluster.status_code, 403)
def test_networks_update_after_deployment(self):
self.create_env_using_statuses(consts.CLUSTER_STATUSES.operational,
consts.NODE_STATUSES.ready)
cluster = self.create_env_using_statuses(
consts.CLUSTER_STATUSES.operational,
consts.NODE_STATUSES.ready)
test_nets = self.env.neutron_networks_get(
self.env.clusters[0].id).json_body
test_nets = self.env.neutron_networks_get(cluster.id).json_body
# change something from 'networking_parameters'
test_nets['networking_parameters']['dns_nameservers'] = \
@ -123,7 +124,7 @@ class TestNetworkModels(BaseIntegrationTest):
mgmt_net['cidr'] = u'1.1.1.0/24'
resp_neutron_net = self.env.neutron_networks_put(
self.env.clusters[0].id, test_nets, expect_errors=True)
cluster.id, test_nets, expect_errors=True)
self.assertEqual(400, resp_neutron_net.status_code)
self.assertEqual(
@ -133,13 +134,11 @@ class TestNetworkModels(BaseIntegrationTest):
mgmt_net['cidr'] = u'192.168.0.0/30'
resp_neutron_net = self.env.neutron_networks_put(
self.env.clusters[0].id, test_nets)
resp_neutron_net = self.env.neutron_networks_put(cluster.id, test_nets)
self.assertEqual(200, resp_neutron_net.status_code)
new_nets = self.env.neutron_networks_get(
self.env.clusters[0].id).json_body
new_nets = self.env.neutron_networks_get(cluster.id).json_body
# test that network was changed
modified_net = filter(lambda x: x['name'] == test_network_name,
@ -151,11 +150,11 @@ class TestNetworkModels(BaseIntegrationTest):
new_nets['networking_parameters'])
def test_admin_network_update_after_deployment(self):
self.create_env_using_statuses(consts.CLUSTER_STATUSES.operational,
consts.NODE_STATUSES.ready)
cluster = self.create_env_using_statuses(
consts.CLUSTER_STATUSES.operational,
consts.NODE_STATUSES.ready)
test_nets = self.env.neutron_networks_get(
self.env.clusters[0].id).json_body
test_nets = self.env.neutron_networks_get(cluster.id).json_body
admin_net = filter(
lambda x: x['name'] == consts.NETWORKS.fuelweb_admin,
@ -165,7 +164,7 @@ class TestNetworkModels(BaseIntegrationTest):
admin_net['ip_ranges'] = [[u'191.111.0.5', u'191.111.0.62']]
resp_neutron_net = self.env.neutron_networks_put(
self.env.clusters[0].id, test_nets, expect_errors=True)
cluster.id, test_nets, expect_errors=True)
self.assertEqual(400, resp_neutron_net.status_code)
self.assertEqual(
"New IP ranges for network '{0}'({1}) do not cover already "
@ -177,7 +176,7 @@ class TestNetworkModels(BaseIntegrationTest):
self.db.commit()
with patch('task.task.rpc.cast'):
resp_neutron_net = self.env.neutron_networks_put(
self.env.clusters[0].id, test_nets)
cluster.id, test_nets)
self.assertEqual(200, resp_neutron_net.status_code)
def test_nova_net_networking_parameters(self):

18
nailgun/nailgun/test/integration/test_network_validation.py
View File

@ -98,7 +98,7 @@ class TestNovaHandlers(TestNetworkChecking):
self.env.set_interfaces_in_meta(meta, [
{"name": "eth0", "mac": "00:00:00:00:00:66"},
{"name": "eth1", "mac": "00:00:00:00:00:77"}])
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.nova_network,
},
@ -108,7 +108,6 @@ class TestNovaHandlers(TestNetworkChecking):
"pending_addition": True},
]
)
self.cluster = self.env.clusters[0]
resp = self.env.nova_networks_get(self.cluster.id)
self.nets = resp.json_body
@ -410,7 +409,7 @@ class TestNeutronHandlersGre(TestNetworkChecking):
self.env.set_interfaces_in_meta(meta, [
{"name": "eth0", "mac": "00:00:00:00:00:66"},
{"name": "eth1", "mac": "00:00:00:00:00:77"}])
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': 'neutron',
'net_segment_type': 'gre'
@ -421,7 +420,6 @@ class TestNeutronHandlersGre(TestNetworkChecking):
'meta': meta}
]
)
self.cluster = self.env.clusters[0]
resp = self.env.neutron_networks_get(self.cluster.id)
self.nets = resp.json_body
@ -803,7 +801,7 @@ class TestNeutronHandlersVlan(TestNetworkChecking):
self.env.set_interfaces_in_meta(meta, [
{"name": "eth0", "mac": "00:00:00:00:00:66"},
{"name": "eth1", "mac": "00:00:00:00:00:77"}])
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': 'neutron',
'net_segment_type': 'vlan'
@ -814,7 +812,6 @@ class TestNeutronHandlersVlan(TestNetworkChecking):
'meta': meta}
]
)
self.cluster = self.env.clusters[0]
resp = self.env.neutron_networks_get(self.cluster.id)
self.nets = resp.json_body
@ -846,7 +843,7 @@ class TestNeutronHandlersTun(TestNetworkChecking):
self.env.set_interfaces_in_meta(meta, [
{"name": "eth0", "mac": "00:00:00:00:00:66"},
{"name": "eth1", "mac": "00:00:00:00:00:77"}])
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': 'neutron',
'net_segment_type': 'tun'
@ -857,7 +854,6 @@ class TestNeutronHandlersTun(TestNetworkChecking):
'meta': meta}
]
)
self.cluster = self.env.clusters[0]
resp = self.env.neutron_networks_get(self.cluster.id)
self.nets = resp.json_body
@ -877,7 +873,7 @@ class TestNetworkConfigurationVerifyHandler(TestNetworkChecking):
self.env.set_interfaces_in_meta(meta, [
{"name": "eth0", "mac": "00:00:00:00:00:66"},
{"name": "eth1", "mac": "00:00:00:00:00:77"}])
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': 'neutron',
'net_segment_type': 'gre'
@ -888,7 +884,6 @@ class TestNetworkConfigurationVerifyHandler(TestNetworkChecking):
'meta': meta}
]
)
self.cluster = self.env.clusters[0]
resp = self.env.neutron_networks_get(self.cluster.id)
self.nets = resp.json_body
@ -914,7 +909,7 @@ class TestNeutronHandlers90(TestNetworkChecking):
net_meta['neutron']['networks'])[0]
bm.update(baremetal_parameters)
self.env.create(
cluster = self.env.create(
release_kwargs={
'networks_metadata': net_meta,
'version': 'mitaka-9.0',
@ -925,7 +920,6 @@ class TestNeutronHandlers90(TestNetworkChecking):
'net_segment_type': 'vlan',
}
)
cluster = self.env.clusters[0]
self.env._set_additional_component(cluster, 'ironic', True)

3
nailgun/nailgun/test/integration/test_node_collection_handlers.py
View File

@ -48,14 +48,13 @@ class TestHandlers(BaseIntegrationTest):
self.assertEqual(node['id'], notif_api['node_id'])
def test_node_get_with_cluster(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={"api": True},
nodes_kwargs=[
{"cluster_id": None},
{},
]
)
cluster = self.env.clusters[0]
resp = self.app.get(
reverse('NodeCollectionHandler'),

9
nailgun/nailgun/test/integration/test_node_deletion.py
View File

@ -33,8 +33,8 @@ class TestNodeDeletion(BaseIntegrationTest):
def setUp(self):
super(TestNodeDeletion, self).setUp()
self.env.create(nodes_kwargs=[{"pending_addition": True}])
self.cluster = self.env.clusters[0]
self.cluster = self.env.create(
nodes_kwargs=[{"pending_addition": True}])
self.node_ids = [node.id for node in self.cluster.nodes]
@fake_tasks()
@ -127,13 +127,12 @@ class TestNodeDeletion(BaseIntegrationTest):
class TestNodeDeletionBadRequest(BaseIntegrationTest):
def test_node_handlers_deletion_bad_request(self):
self.env.create(nodes_kwargs=[
cluster = self.env.create(nodes_kwargs=[
{'roles': ['controller'], 'status': consts.NODE_STATUSES.error}
])
cluster_db = self.env.clusters[0]
node_to_delete = self.env.create_node(
cluster_id=cluster_db.id,
cluster_id=cluster.id,
roles=['controller'],
status=consts.NODE_STATUSES.ready
)

3
nailgun/nailgun/test/integration/test_node_handler.py
View File

@ -284,7 +284,7 @@ class TestHandlers(BaseIntegrationTest):
@fake_tasks()
def test_interface_changes_for_new_node(self):
# Creating cluster with node
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'name': 'test_name'
},
@ -292,7 +292,6 @@ class TestHandlers(BaseIntegrationTest):
{'roles': ['controller'], 'pending_addition': True}
]
)
cluster = self.env.clusters[0]
def filter_changes(chg_type, chg_list):
return filter(lambda x: x.get('name') == chg_type, chg_list)

28
nailgun/nailgun/test/integration/test_node_nic_assignment.py
View File

@ -21,7 +21,6 @@ from netaddr import IPNetwork
from oslo_serialization import jsonutils
from nailgun import consts
from nailgun.db.sqlalchemy.models import Cluster
from nailgun.db.sqlalchemy.models import NetworkNICAssignment
from nailgun import objects
from nailgun.test.base import BaseIntegrationTest
@ -92,8 +91,7 @@ class TestClusterHandlers(BaseIntegrationTest):
{'name': 'eth1', 'mac': self.env.generate_random_mac()}])
node = self.env.create_node(api=True, meta=meta, mac=mac)
cluster = self.env.create_cluster(api=True, nodes=[node['id']])
cluster_db = self.db.query(Cluster).get(cluster['id'])
self.db.delete(cluster_db)
self.db.delete(cluster)
self.db.commit()
net_assignment = self.db.query(NetworkNICAssignment).all()
@ -479,7 +477,7 @@ class TestNodeNICsSerialization(BaseIntegrationTest):
def check_nics_interface_properties(self, handler):
for ver, present in self.versions:
self.env.create(
cluster = self.env.create(
release_kwargs={'version': ver},
nodes_kwargs=[
{'roles': ['controller'],
@ -497,7 +495,7 @@ class TestNodeNICsSerialization(BaseIntegrationTest):
self.assertEqual('interface_properties' in resp.json_body[0],
present)
objects.Node.delete(node)
objects.Cluster.delete(self.env.clusters[0])
objects.Cluster.delete(cluster)
self.env.nodes = []
self.env.clusters = []
@ -575,7 +573,7 @@ class TestNodeNICAdminAssigning(BaseIntegrationTest):
class TestNodePublicNetworkToNICAssignment(BaseIntegrationTest):
def create_node_and_check_assignment(self):
def create_node_and_check_assignment(self, cluster):
meta = self.env.default_metadata()
admin_ip = str(IPNetwork(
objects.NetworkGroup.get_admin_network_group().cidr)[1])
@ -589,7 +587,7 @@ class TestNodePublicNetworkToNICAssignment(BaseIntegrationTest):
]
node = self.env.create_node(
api=True, meta=meta, mac=admin_mac, ip=admin_ip,
cluster_id=self.env.clusters[0].id)
cluster_id=cluster.id)
resp = self.app.get(
reverse('NodeNICsHandler', kwargs={'node_id': node['id']}),
@ -604,39 +602,39 @@ class TestNodePublicNetworkToNICAssignment(BaseIntegrationTest):
1)
def test_nova_net_public_network_assigned_to_second_nic_by_name(self):
self.env.create_cluster(
cluster = self.env.create_cluster(
api=True,
net_provider=consts.CLUSTER_NET_PROVIDERS.nova_network,
editable_attributes={'public_network_assignment': {
'assign_to_all_nodes': {'value': True}}})
self.create_node_and_check_assignment()
self.create_node_and_check_assignment(cluster)
def test_neutron_gre_public_network_assigned_to_second_nic_by_name(self):
self.env.create_cluster(
cluster = self.env.create_cluster(
api=True,
net_provider='neutron',
net_segment_type='gre',
editable_attributes={'public_network_assignment': {
'assign_to_all_nodes': {'value': True}}})
self.create_node_and_check_assignment()
self.create_node_and_check_assignment(cluster)
def test_neutron_tun_public_network_assigned_to_second_nic_by_name(self):
self.env.create_cluster(
cluster = self.env.create_cluster(
api=True,
net_provider='neutron',
net_segment_type='tun',
editable_attributes={'public_network_assignment': {
'assign_to_all_nodes': {'value': True}}})
self.create_node_and_check_assignment()
self.create_node_and_check_assignment(cluster)
def test_neutron_vlan_public_network_assigned_to_second_nic_by_name(self):
self.env.create_cluster(
cluster = self.env.create_cluster(
api=True,
net_provider='neutron',
net_segment_type='vlan',
editable_attributes={'public_network_assignment': {
'assign_to_all_nodes': {'value': True}}})
self.create_node_and_check_assignment()
self.create_node_and_check_assignment(cluster)
class TestNodeNICsHandlersValidation(BaseIntegrationTest):

3
nailgun/nailgun/test/integration/test_node_nic_collection_handler.py
View File

@ -84,8 +84,7 @@ class TestNodeCollectionNICsHandler(BaseIntegrationTest):
@fake_tasks()
def test_interface_changes_added(self):
# Creating cluster with node
self.env.create_cluster()
cluster = self.env.clusters[0]
cluster = self.env.create_cluster()
self.env.create_nodes_w_interfaces_count(
roles=['controller'],
pending_addition=True,

15
nailgun/nailgun/test/integration/test_node_nic_handler.py
View File

@ -653,12 +653,12 @@ class TestHandlers(BaseIntegrationTest):
def get_nodes():
resp = self.app.get(
reverse('NodeCollectionHandler',
kwargs={'cluster_id': self.env.clusters[0].id}),
kwargs={'cluster_id': cluster.id}),
headers=self.default_headers,
)
return resp.json_body
self.env.create(nodes_kwargs=[{'api': True}])
cluster = self.env.create(nodes_kwargs=[{'api': True}])
# check all possible handlers
for handler in ('NodeAgentHandler',
@ -724,7 +724,7 @@ class TestHandlers(BaseIntegrationTest):
def get_nodes():
resp = self.app.get(
reverse('NodeCollectionHandler',
kwargs={'cluster_id': self.env.clusters[0].id}),
kwargs={'cluster_id': cluster.id}),
headers=self.default_headers,
)
return resp.json_body
@ -738,7 +738,7 @@ class TestHandlers(BaseIntegrationTest):
{'name': 'eth3', 'mac': self.env.generate_random_mac()},
{'name': 'eth4', 'mac': self.env.generate_random_mac()},
]
self.env.create(nodes_kwargs=[{'api': True, 'meta': meta}])
cluster = self.env.create(nodes_kwargs=[{'api': True, 'meta': meta}])
# check all possible handlers
for handler in ('NodeAgentHandler',
@ -791,9 +791,8 @@ class TestHandlers(BaseIntegrationTest):
{'name': 'eth0', 'mac': self.env.generate_random_mac(),
'pxe': False},
]
self.env.create(nodes_kwargs=[{'api': False, 'meta': meta}])
cluster = self.env.create(nodes_kwargs=[{'api': False, 'meta': meta}])
cluster = self.env.clusters[0]
node = cluster.nodes[0]
# Processing data through NodeHandler
@ -829,7 +828,7 @@ class TestSriovHandlers(BaseIntegrationTest):
def setUp(self):
super(TestSriovHandlers, self).setUp()
self.env.create_cluster(
cluster = self.env.create_cluster(
editable_attributes={
'common': {
'libvirt_type': {
@ -839,7 +838,7 @@ class TestSriovHandlers(BaseIntegrationTest):
}
)
self.env.create_nodes_w_interfaces_count(
1, 3, cluster_id=self.env.clusters[0].id, api=True)
1, 3, cluster_id=cluster.id, api=True)
self.nics = self.get_node_interfaces()
def get_node_interfaces(self):

6
nailgun/nailgun/test/integration/test_node_nic_handlers_w_bonding.py
View File

@ -96,7 +96,7 @@ class TestNodeNICsBonding(BaseIntegrationTest):
}}
])
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
"net_provider": "neutron",
"net_segment_type": "gre"
@ -267,7 +267,7 @@ class TestNodeNICsBonding(BaseIntegrationTest):
resp = self.app.post(
reverse(
'NodeUnassignmentHandler',
kwargs={'cluster_id': self.env.clusters[0]['id']}
kwargs={'cluster_id': self.cluster.id}
),
jsonutils.dumps([{'id': node.id}]),
headers=self.default_headers
@ -288,7 +288,7 @@ class TestNodeNICsBonding(BaseIntegrationTest):
node = self.env.nodes[0]
resp = self.app.put(
reverse('ClusterHandler',
kwargs={'obj_id': self.env.clusters[0]['id']}),
kwargs={'obj_id': self.cluster.id}),
jsonutils.dumps({'nodes': []}),
headers=self.default_headers,
expect_errors=True

14
nailgun/nailgun/test/integration/test_notification.py
View File

@ -88,13 +88,13 @@ class TestNotification(BaseIntegrationTest):
self.assertEqual(len(notifications), 0)
def test_notification_deploy_error_with_nodes(self):
self.env.create(api=False,
nodes_kwargs=[
{
'status': consts.NODE_STATUSES.error,
'error_type': consts.NODE_ERRORS.deploy
}])
cluster = self.env.clusters[0]
cluster = self.env.create(
api=False,
nodes_kwargs=[
{
'status': consts.NODE_STATUSES.error,
'error_type': consts.NODE_ERRORS.deploy
}])
receiver = rcvr.NailgunReceiver()
task = Task(

3
nailgun/nailgun/test/integration/test_openstack_config_task_manager.py
View File

@ -28,7 +28,7 @@ class TestOpenstackConfigTaskManager80(base.BaseIntegrationTest):
def setUp(self):
super(TestOpenstackConfigTaskManager80, self).setUp()
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={'net_provider': 'neutron',
'net_segment_type': 'gre'},
release_kwargs={'version': self.env_version,
@ -42,7 +42,6 @@ class TestOpenstackConfigTaskManager80(base.BaseIntegrationTest):
)
self.release = self.env.releases[0]
self.cluster = self.env.clusters[0]
self.nodes = self.env.nodes
# this mock configuration is used to insert into DB

6
nailgun/nailgun/test/integration/test_orchestrator_handlers.py
View File

@ -171,7 +171,7 @@ class BaseSelectedNodesTest(BaseIntegrationTest):
def setUp(self):
super(BaseSelectedNodesTest, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True},
{'roles': ['controller'], 'pending_addition': True},
@ -182,7 +182,6 @@ class BaseSelectedNodesTest(BaseIntegrationTest):
{'roles': ['mongo'], 'pending_addition': True},
{'roles': ['cinder'], 'pending_addition': True}])
self.cluster = self.env.clusters[0]
self.nodes = [n for n in self.cluster.nodes][:3]
self.node_uids = [n.uid for n in self.nodes]
@ -610,11 +609,10 @@ class TestSerializedTasksHandler(BaseIntegrationTest):
def setUp(self):
super(TestSerializedTasksHandler, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True},
{'roles': ['compute'], 'pending_addition': True}])
self.cluster = self.env.clusters[-1]
self.nodes = self.cluster.nodes
objects.Cluster.prepare_for_deployment(
self.cluster, self.cluster.nodes)

4
nailgun/nailgun/test/integration/test_orchestrator_serializer.py
View File

@ -2577,7 +2577,7 @@ class TestDeploymentAttributesSerialization61(BaseDeploymentSerializer):
return_value=False)
def test_serialize_workloads_collector_user_opted_out(self, _):
oswl_user = self.serializer.get_common_attrs(
self.env.clusters[0]
self.cluster
)['workloads_collector']
self.assertEqual(set(oswl_user.keys()),
set(['username',
@ -2596,7 +2596,7 @@ class TestDeploymentAttributesSerialization61(BaseDeploymentSerializer):
return_value=True)
def test_serialize_workloads_collector_user_opted_in(self, _):
oswl_user = self.serializer.get_common_attrs(
self.env.clusters[0]
self.cluster
)['workloads_collector']
self.assertEqual(set(oswl_user.keys()),
set(['username',

18
nailgun/nailgun/test/integration/test_orchestrator_serializer_70.py
View File

@ -613,7 +613,7 @@ class TestDeploymentSerializationForNovaNetwork70(
self.assertEqual(roles, expected_roles)
def test_network_metadata(self):
nm = objects.Cluster.get_network_manager(self.env.clusters[0])
nm = objects.Cluster.get_network_manager(self.cluster)
ip_by_net = {
'fuelweb_admin': None,
'storage': None,
@ -746,7 +746,7 @@ class TestPluginDeploymentTasksInjection70(base.BaseIntegrationTest):
def setUp(self):
super(TestPluginDeploymentTasksInjection70, self).setUp()
# Plugin task injection for Task based is checked in task based tests
self.env.create(
self.cluster = self.env.create(
release_kwargs={
'deployment_tasks': self.release_deployment_tasks,
'version': self.env_version
@ -762,8 +762,6 @@ class TestPluginDeploymentTasksInjection70(base.BaseIntegrationTest):
]
)
self.cluster = self.env.clusters[0]
self.plugin_data = {
'package_version': '3.0.0',
'releases': [
@ -1077,7 +1075,7 @@ class TestRolesSerializationWithPlugins(BaseDeploymentSerializer,
super(TestRolesSerializationWithPlugins, self).setUp()
release = self.patch_net_roles_for_release()
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'release_id': release.id,
'mode': consts.CLUSTER_MODES.ha_compact,
@ -1085,8 +1083,6 @@ class TestRolesSerializationWithPlugins(BaseDeploymentSerializer,
'net_segment_type': consts.NEUTRON_SEGMENT_TYPES.vlan,
})
self.cluster = self.env.clusters[0]
self.plugin_data = {
'package_version': '3.0.0',
'releases': [
@ -1572,7 +1568,7 @@ class TestNetworkTemplateSerializer70(BaseDeploymentSerializer,
self.assertEqual(node_attrs['swift_zone'], node.uid)
def test_multiple_node_roles_network_metadata_roles(self):
nm = objects.Cluster.get_network_manager(self.env.clusters[0])
nm = objects.Cluster.get_network_manager(self.cluster)
ip_by_net = {}
for node_data in self.serialized_for_astute:
nodes = node_data['network_metadata']['nodes']
@ -1664,7 +1660,7 @@ class TestNetworkTemplateSerializer70(BaseDeploymentSerializer,
# networks to interfaces mapping
resp = self.app.get(
reverse('NetworkGroupCollectionHandler',
kwargs=self.env.clusters[0]),
kwargs=self.cluster),
headers=self.default_headers,
expect_errors=False
)
@ -1688,7 +1684,7 @@ class TestNetworkTemplateSerializer70(BaseDeploymentSerializer,
)
resp = self.app.get(
reverse('NetworkGroupCollectionHandler',
kwargs=self.env.clusters[0]),
kwargs=self.cluster),
headers=self.default_headers,
expect_errors=False
)
@ -1756,7 +1752,7 @@ class TestNetworkTemplateSerializer70(BaseDeploymentSerializer,
net_template
)
cluster_db = self.db.query(models.Cluster).get(self.cluster['id'])
nm = objects.Cluster.get_network_manager(self.env.clusters[0])
nm = objects.Cluster.get_network_manager(self.cluster)
serializer = get_serializer_for_cluster(self.cluster)
self.serialized_for_astute = serializer(
AstuteGraph(cluster_db)).serialize(self.cluster, cluster_db.nodes)

6
nailgun/nailgun/test/integration/test_orchestrator_serializer_80.py
View File

@ -91,14 +91,13 @@ class TestNetworkTemplateSerializer80(
def setUp(self, *args):
super(TestNetworkTemplateSerializer80, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={'version': self.env_version},
cluster_kwargs={
'mode': consts.CLUSTER_MODES.ha_compact,
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
'net_segment_type': consts.NEUTRON_SEGMENT_TYPES.vlan})
self.net_template = self.env.read_fixtures(['network_template_80'])[0]
self.cluster = self.env.clusters[-1]
self.serializer = self.create_serializer(self.cluster)
def test_get_net_provider_serializer(self):
@ -210,7 +209,7 @@ class TestDeploymentTasksSerialization80(
def setUp(self):
super(TestDeploymentTasksSerialization80, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={'version': self.env_version},
cluster_kwargs={
'mode': consts.CLUSTER_MODES.ha_compact,
@ -222,7 +221,6 @@ class TestDeploymentTasksSerialization80(
'status': consts.NODE_STATUSES.ready}]
)
self.cluster = self.env.clusters[-1]
if not self.task_deploy:
self.env.disable_task_deploy(self.cluster)

13
nailgun/nailgun/test/integration/test_orchestrator_serializer_90.py
View File

@ -610,7 +610,7 @@ class TestDeploymentHASerializer90(
def test_ceph_keys(self):
storage_attrs = self.serializer.get_common_attrs(
self.env.clusters[0]
self.cluster
)['storage']
expected_keys = (
'fsid', 'mon_key', 'admin_key', 'bootstrap_osd_key', 'radosgw_key'
@ -764,7 +764,7 @@ class TestSriovSerialization90(
):
def setUp(self, *args):
super(TestSriovSerialization90, self).setUp()
cluster = self.env.create(
self.cluster_db = self.env.create(
release_kwargs={'version': self.env_version},
cluster_kwargs={
'mode': consts.CLUSTER_MODES.ha_compact,
@ -772,15 +772,14 @@ class TestSriovSerialization90(
'net_segment_type': consts.NEUTRON_SEGMENT_TYPES.vlan,
'status': consts.CLUSTER_STATUSES.new},
)
self.cluster_db = objects.Cluster.get_by_uid(cluster['id'])
self.env.create_nodes_w_interfaces_count(
nodes_count=1, if_count=3, cluster_id=self.env.clusters[0].id,
nodes_count=1, if_count=3, cluster_id=self.cluster_db.id,
pending_roles=['compute'], pending_addition=True)
def serialize(self):
objects.Cluster.prepare_for_deployment(self.env.clusters[0])
serializer = self.create_serializer(self.env.clusters[0])
return serializer.serialize(self.env.clusters[0], self.env.nodes)
objects.Cluster.prepare_for_deployment(self.cluster_db)
serializer = self.create_serializer(self.cluster_db)
return serializer.serialize(self.cluster_db, self.env.nodes)
def test_nic_sriov_info_is_serialized(self):
for nic in self.env.nodes[0].nic_interfaces:

15
nailgun/nailgun/test/integration/test_plugin_manager.py
View File

@ -29,13 +29,12 @@ class TestPluginManager(base.BaseIntegrationTest):
def setUp(self):
super(TestPluginManager, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={
'version': '2015.1-8.0',
'operating_system': 'Ubuntu'})
self.release = self.env.releases[0]
self.cluster = self.env.clusters[0]
# Create two plugins with package verion 3.0.0
for name in ['test_plugin_1', 'test_plugin_2']:
@ -286,8 +285,7 @@ class TestPluginManager(base.BaseIntegrationTest):
self.assertItemsEqual([plugin], enabled_plugins)
def test_get_plugins_attributes_when_cluster_is_locked(self):
self.env.create(api=False)
cluster = self.env.clusters[-1]
cluster = self.env.create(api=False)
plugin_a1 = self.env.create_plugin(
name='plugin_a', version='1.0.1',
cluster=cluster, enabled=False
@ -361,8 +359,7 @@ class TestPluginManager(base.BaseIntegrationTest):
)
def test_get_plugins_attributes_when_cluster_is_not_locked(self):
self.env.create(api=False)
cluster = self.env.clusters[-1]
cluster = self.env.create(api=False)
plugin_a1 = self.env.create_plugin(
name='plugin_a', version='1.0.1',
cluster=cluster, enabled=False
@ -459,14 +456,13 @@ class TestClusterPluginIntegration(base.BaseTestCase):
def setUp(self):
super(TestClusterPluginIntegration, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={
'operating_system': consts.RELEASE_OS.ubuntu,
'version': '2015.1-8.0'},
cluster_kwargs={
'mode': consts.CLUSTER_MODES.ha_compact,
})
self.cluster = self.env.clusters[0]
def _create_plugin(self, **kwargs):
plugin = self.env.create_plugin(name=uuid.uuid4().get_hex(), **kwargs)
@ -484,12 +480,11 @@ class TestClusterPluginIntegration(base.BaseTestCase):
plugin_b = self._create_plugin(**self._compat_meta)
self._create_plugin(**self._uncompat_meta)
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'release_id': self.cluster.release.id,
'mode': consts.CLUSTER_MODES.ha_compact,
})
cluster = self.env.clusters[1]
compat_plugins = ClusterPlugins.get_compatible_plugins(cluster)
self.assertItemsEqual(compat_plugins, [plugin_a, plugin_b])

4
nailgun/nailgun/test/integration/test_plugins_api.py
View File

@ -52,12 +52,12 @@ class BasePluginTest(base.BaseIntegrationTest):
def create_cluster(self, nodes=None):
nodes = nodes if nodes else []
self.env.create(
cluster = self.env.create(
release_kwargs={'version': '2014.2-6.0',
'operating_system': 'Ubuntu',
'deployment_tasks': []},
nodes_kwargs=nodes)
return self.env.clusters[0]
return cluster
def default_attributes(self, cluster):
resp = self.app.get(

12
nailgun/nailgun/test/integration/test_provisioning.py
View File

@ -28,7 +28,7 @@ class TestProvisioning(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_nodes_in_cluster(self, mocked_rpc):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
@ -36,18 +36,17 @@ class TestProvisioning(BaseIntegrationTest):
{"api": False, "cluster_id": None}
]
)
cluster_db = self.env.clusters[0]
for node in self.env.nodes[:2]:
cluster_db.nodes.append(node)
self.db.add(cluster_db)
cluster.nodes.append(node)
self.db.add(cluster)
self.db.commit()
self.assertEqual(len(cluster_db.nodes), 2)
self.assertEqual(len(cluster.nodes), 2)
@fake_tasks(fake_rpc=False, mock_rpc=False)
@patch('nailgun.rpc.cast')
def test_node_status_changes_to_provision(self, mocked_rpc=None):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, "status": consts.NODE_STATUSES.ready},
@ -67,7 +66,6 @@ class TestProvisioning(BaseIntegrationTest):
"error_type": "provision"}
]
)
cluster = self.env.clusters[0]
objects.Cluster.clear_pending_changes(cluster)
self.env.network_manager.assign_ips(
cluster, self.env.nodes, consts.NETWORKS.fuelweb_admin

11
nailgun/nailgun/test/integration/test_provisioning_serializer.py
View File

@ -97,8 +97,7 @@ class TestProvisioningSerializer(BaseIntegrationTest):
def setUp(self):
super(TestProvisioningSerializer, self).setUp()
self.env.create()
self.cluster_db = self.env.clusters[0]
self.cluster_db = self.env.create()
self.env.create_nodes_w_interfaces_count(
1, 1,
**{
@ -191,7 +190,6 @@ class TestProvisioningSerializer(BaseIntegrationTest):
self.assertEqual(node['ks_meta']['mco_identity'], node_db.id)
def test_node_serialization_w_bonded_admin_iface(self):
self.cluster_db = self.env.clusters[0]
# create additional node to test bonding
admin_mac = self.env.generate_random_mac()
meta = {
@ -409,10 +407,9 @@ class TestProvisioningSerializer90(BaseIntegrationTest):
serializer = ps.ProvisioningSerializer90
def test_user_account_info(self):
self.env.create(
self.cluster_db = self.env.create(
release_kwargs={'version': 'liberty-9.0'},
)
self.cluster_db = self.env.clusters[0]
self.env.create_nodes_w_interfaces_count(
1, 1,
roles=['controller'],
@ -470,7 +467,7 @@ class TestProvisioningSerializer90(BaseIntegrationTest):
)
def test_serialize_iommu_parameters_for_sriov(self):
self.env.create(
cluster = self.env.create(
release_kwargs={
'version': 'liberty-9.0',
'operating_system': consts.RELEASE_OS.ubuntu},
@ -484,7 +481,7 @@ class TestProvisioningSerializer90(BaseIntegrationTest):
objects.NIC.update(sriov_nic, {})
serialized_node = self.serializer.serialize(
self.env.clusters[0], self.env.nodes)['nodes'][0]
cluster, self.env.nodes)['nodes'][0]
kernel_opts = serialized_node['ks_meta']['pm_data']['kernel_params']
self.assertIn("intel_iommu=on", kernel_opts)
self.assertIn("amd_iommu=on", kernel_opts)

1
nailgun/nailgun/test/integration/test_put_same_json.py
View File

@ -43,7 +43,6 @@ class TestPutSameJson(base.BaseIntegrationTest):
{'api': True, 'pending_addition': True, 'meta': meta_p},
]
)
self.cluster = self.env.clusters[0]
def assertHttpPut(self, name, arguments, data, expected_status):
"""Helper assert for checking HTTP PUT.

9
nailgun/nailgun/test/integration/test_reset_environment.py
View File

@ -33,7 +33,7 @@ class TestResetEnvironment(BaseIntegrationTest):
ia_nodes_count=1
)
def test_reset_environment(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"name": "First",
@ -43,7 +43,6 @@ class TestResetEnvironment(BaseIntegrationTest):
"pending_addition": True}
]
)
cluster_db = self.env.clusters[0]
supertask = self.env.launch_deployment()
self.assertEqual(supertask.status, consts.TASK_STATUSES.ready)
@ -92,13 +91,12 @@ class TestResetEnvironment(BaseIntegrationTest):
ia_nodes_count=1
)
def test_reset_node_pending_statuses(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"pending_addition": True},
]
)
cluster_db = self.env.clusters[0]
node_db = self.env.nodes[0]
# deploy environment
@ -131,7 +129,7 @@ class TestResetEnvironment(BaseIntegrationTest):
ia_nodes_count=1
)
def test_reset_environment_tasks(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"name": "First",
@ -141,7 +139,6 @@ class TestResetEnvironment(BaseIntegrationTest):
"pending_addition": True}
]
)
cluster_db = self.env.clusters[0]
supertask = self.env.launch_deployment()
self.assertEqual(supertask.status, consts.TASK_STATUSES.ready)

98
nailgun/nailgun/test/integration/test_rpc_consumer.py
View File

@ -57,14 +57,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
return nodes_message
def test_verify_networks_resp(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets = [{'iface': 'eth0', 'vlans': range(100, 105)}]
@ -92,14 +91,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
self.assertEqual(task.message, '')
def test_verify_networks_error_and_notice_are_concatenated(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False},
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets = [{'iface': 'eth0', 'vlans': range(100, 105)}]
@ -132,14 +130,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
'\n'.join((custom_error, offline_notice)))
def test_verify_networks_resp_error(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
nets_resp = [{'iface': 'eth0', 'vlans': range(100, 104)}]
@ -173,7 +170,7 @@ class TestVerifyNetworks(BaseReciverTestCase):
self.assertEqual(task.result, error_nodes)
def test_verify_networks_resp_error_with_removed_node(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
@ -181,7 +178,6 @@ class TestVerifyNetworks(BaseReciverTestCase):
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
nets_resp = [{'iface': 'eth0', 'vlans': range(100, 104)}]
@ -227,14 +223,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
self.assertEqual(task['result'], error_nodes)
def test_verify_networks_resp_empty_nodes_custom_error(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
@ -263,14 +258,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
self.assertEqual(task.message, error_msg)
def test_verify_networks_resp_extra_nodes_error(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
node3 = self.env.create_node(api=False)
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
@ -304,14 +298,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
Test verifies that when dhcp subtask is ready and
verify_networks errored - verify_networks will be in error
"""
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
@ -343,14 +336,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
self.assertEqual(task.status, "error")
def test_verify_networks_with_dhcp_subtask_erred(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
@ -393,7 +385,7 @@ class TestVerifyNetworks(BaseReciverTestCase):
u'uid': node2.id}])
def test_verify_networks_resp_forgotten_node_error(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, 'name': 'node1'},
@ -401,7 +393,6 @@ class TestVerifyNetworks(BaseReciverTestCase):
{"api": False, 'name': 'node3'}
]
)
cluster_db = self.env.clusters[0]
node1, node2, node3 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
@ -436,7 +427,7 @@ class TestVerifyNetworks(BaseReciverTestCase):
self.env.set_interfaces_in_meta(
meta, [{'name': 'eth0', 'mac': mac}])
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, 'name': 'node1'},
@ -444,7 +435,6 @@ class TestVerifyNetworks(BaseReciverTestCase):
{"api": False, 'name': 'node3'}
]
)
cluster_db = self.env.clusters[0]
node1, node2, node3 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)},
@ -495,14 +485,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
def test_verify_networks_resp_incomplete_network_data_on_first_node(self):
"""First node network data incompletion causes task fail"""
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, 'name': 'node1'},
{"api": False, 'name': 'node2'},
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': range(100, 105)}]
@ -543,14 +532,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
Passes when only iface without vlans configured
"""
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': [0]},
{'iface': 'eth1', 'vlans': [0]}]
@ -578,14 +566,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
def test_verify_networks_resp_without_vlans_only_erred(self):
"""Net verification without vlans fails when not all info received"""
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': [0]}]
nets_resp = [{'iface': 'eth0', 'vlans': []}]
@ -624,14 +611,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
def test_verify_networks_resp_partially_without_vlans(self):
"""Verify that network verification partially without vlans passes"""
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': [0]},
{'iface': 'eth1', 'vlans': range(100, 104)}]
@ -659,14 +645,13 @@ class TestVerifyNetworks(BaseReciverTestCase):
def test_verify_networks_with_excluded_networks(self):
"""Verify that network verification can exclude interfaces"""
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
nets_sent = [{'iface': 'eth0', 'vlans': [0]},
{'iface': 'eth1', 'vlans': range(100, 104)}]
@ -733,14 +718,13 @@ class TestDhcpCheckTask(BaseReciverTestCase):
def setUp(self):
super(TestDhcpCheckTask, self).setUp()
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
self.node1, self.node2 = self.env.nodes
self.task = Task(
@ -822,7 +806,7 @@ class TestDhcpCheckTask(BaseReciverTestCase):
class TestConsumer(BaseReciverTestCase):
def test_node_deploy_resp(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
@ -834,7 +818,7 @@ class TestConsumer(BaseReciverTestCase):
task = Task(
uuid=str(uuid.uuid4()),
name="deploy",
cluster_id=self.env.clusters[0].id
cluster_id=cluster.id
)
self.db.add(task)
self.db.commit()
@ -852,7 +836,7 @@ class TestConsumer(BaseReciverTestCase):
self.assertEqual(task.status, "running")
def test_node_provision_resp(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
@ -862,7 +846,7 @@ class TestConsumer(BaseReciverTestCase):
task = Task(
name='provision',
cluster_id=self.env.clusters[0].id)
cluster_id=cluster.id)
self.db.add(task)
self.db.commit()
@ -932,7 +916,7 @@ class TestConsumer(BaseReciverTestCase):
self.db.delete(al)
self.db.commit()
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'api': False},
{'api': False}
@ -953,19 +937,19 @@ class TestConsumer(BaseReciverTestCase):
]
for kw in test_cases_kwargs:
kw['cluster_id'] = self.env.clusters[0].id
kw['cluster_id'] = cluster.id
kw['node_ids'] = [node.id, node2.id]
check_write_logs_from_receiver(**kw)
def test_task_progress(self):
self.env.create_cluster()
cluster = self.env.create_cluster()
task = Task(
uuid=str(uuid.uuid4()),
name="super",
status="running",
cluster_id=self.env.clusters[0].id
cluster_id=cluster.id
)
self.db.add(task)
self.db.commit()
@ -1080,7 +1064,7 @@ class TestConsumer(BaseReciverTestCase):
self.assertEqual(supertask.progress, calculated_progress)
def _prepare_task(self, name):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
@ -1091,7 +1075,7 @@ class TestConsumer(BaseReciverTestCase):
uuid=str(uuid.uuid4()),
name=name,
status=consts.TASK_STATUSES.running,
cluster_id=self.env.clusters[0].id
cluster_id=cluster.id
)
self.db.add(task)
self.db.flush()
@ -1228,14 +1212,13 @@ class TestConsumer(BaseReciverTestCase):
u"Provision has failed\. Check these nodes:\n'(.*)', '(.*)'")
def test_remove_nodes_resp(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
task = Task(
@ -1267,14 +1250,13 @@ class TestConsumer(BaseReciverTestCase):
self.assertEqual(len(nodes_db), 0)
def test_remove_nodes_resp_failure(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
task = Task(
@ -1366,8 +1348,7 @@ class TestConsumer(BaseReciverTestCase):
self.assertIsNone(cluster_db)
def test_remove_images_resp(self):
self.env.create()
cluster_db = self.env.clusters[0]
cluster_db = self.env.create()
task = Task(
name=consts.TASK_NAMES.remove_images,
@ -1388,8 +1369,7 @@ class TestConsumer(BaseReciverTestCase):
self.assertEqual(consts.TASK_STATUSES.ready, task.status)
def test_remove_images_resp_failed(self):
self.env.create()
cluster_db = self.env.clusters[0]
cluster_db = self.env.create()
task = Task(
name=consts.TASK_NAMES.remove_images,
@ -1410,14 +1390,13 @@ class TestConsumer(BaseReciverTestCase):
self.assertEqual(consts.TASK_STATUSES.error, task.status)
def test_remove_cluster_resp_failed(self):
self.env.create(
cluster_db = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False},
{"api": False}
]
)
cluster_db = self.env.clusters[0]
node1, node2 = self.env.nodes
self.env.create_notification(
cluster_id=cluster_db.id
@ -1458,19 +1437,18 @@ class TestConsumer(BaseReciverTestCase):
nets_db = self.db.query(NetworkGroup).\
filter(NetworkGroup.group_id ==
objects.Cluster.get_default_group(
self.env.clusters[0]).id).\
cluster_db).id).\
all()
self.assertNotEqual(len(nets_db), 0)
def test_provision_resp_master_uid(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, "status": consts.NODE_STATUSES.provisioning},
{"api": False, "status": consts.NODE_STATUSES.provisioning},
]
)
cluster = self.env.clusters[0]
node1, node2 = self.env.nodes
task = Task(
@ -1501,7 +1479,7 @@ class TestConsumer(BaseReciverTestCase):
self.assertEqual(node2.error_type, consts.NODE_ERRORS.provision)
def test_update_config_resp(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{'api': False, 'roles': ['controller'],
@ -1515,7 +1493,7 @@ class TestConsumer(BaseReciverTestCase):
task = Task(
uuid=str(uuid.uuid4()),
name=consts.TASK_NAMES.deployment,
cluster_id=self.env.clusters[0].id
cluster_id=cluster.id
)
task.cache = {'nodes': [nodes[0].uid, nodes[1].uid]}
self.db.add(task)
@ -1536,7 +1514,7 @@ class TestConsumer(BaseReciverTestCase):
self.assertEqual(task.status, consts.TASK_STATUSES.ready)
def _check_success_message(self, callback, task_name, c_status, n_status):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{'api': False, 'roles': ['controller'],
@ -1544,7 +1522,6 @@ class TestConsumer(BaseReciverTestCase):
{'api': False, 'roles': ['compute'],
'status': consts.NODE_STATUSES.discover},
])
cluster = self.env.clusters[-1]
nodes = self.env.nodes
task_title = task_name.title()
task = Task(
@ -1608,13 +1585,12 @@ class TestResetEnvironment(BaseReciverTestCase):
@mock.patch('nailgun.rpc.receiver.logs_utils.delete_node_logs')
def test_delete_logs_after_reset(self, mock_delete_logs):
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": False, "status": consts.NODE_STATUSES.ready},
]
)
cluster = self.env.clusters[0]
node = self.env.nodes[0]

9
nailgun/nailgun/test/integration/test_spawning_vms.py
View File

@ -27,13 +27,12 @@ class TestSpawnVMs(BaseIntegrationTest):
@fake_tasks(recover_nodes=False)
def test_spawn_vms(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"status": "ready", "pending_addition": True,
"roles": ["virt"]},
]
)
cluster = self.env.clusters[0]
cluster.nodes[0].vms_conf = [{'id': 1, 'cluster_id': cluster.id}]
resp = self.app.put(
@ -51,13 +50,12 @@ class TestSpawnVMs(BaseIntegrationTest):
self.assertEqual(len(task_deploy.subtasks), 2)
def test_create_vms_conf(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"status": "ready", "pending_addition": True,
"roles": ["virt"]},
]
)
cluster = self.env.clusters[0]
vms_conf = {"vms_conf": [{'id': 1, 'cluster_id': cluster.id}]}
self.app.put(
reverse(
@ -75,13 +73,12 @@ class TestSpawnVMs(BaseIntegrationTest):
self.assertEqual(spawning_nodes.json, vms_conf)
def test_spawn_vms_error(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"pending_addition": True,
"roles": ["compute"]},
]
)
cluster = self.env.clusters[0]
resp = self.app.put(
reverse(

4
nailgun/nailgun/test/integration/test_stats_user_task_manager.py
View File

@ -114,7 +114,7 @@ class TestStatsUserTaskManagers(BaseMasterNodeSettignsTest):
@fake_tasks(override_state={'progress': 100,
'status': consts.TASK_STATUSES.ready})
def test_no_tasks_for_non_operational_clusters(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True},
]
@ -123,8 +123,6 @@ class TestStatsUserTaskManagers(BaseMasterNodeSettignsTest):
deploy_task = self.env.launch_deployment()
self.assertEqual(deploy_task.status, consts.TASK_STATUSES.ready)
cluster = self.env.clusters[0]
# Tuple of tuples (task_name, must_send_stats)
tasks_params = (
(consts.TASK_NAMES.create_stats_user, True),

3
nailgun/nailgun/test/integration/test_stop_deployment.py
View File

@ -31,7 +31,7 @@ class TestStopDeployment(BaseIntegrationTest):
def setUp(self):
super(TestStopDeployment, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{"name": "First",
"pending_addition": True},
@ -40,7 +40,6 @@ class TestStopDeployment(BaseIntegrationTest):
"pending_addition": True}
]
)
self.cluster = self.env.clusters[0]
self.controller = self.env.nodes[0]
self.compute = self.env.nodes[1]
self.node_uids = [n.uid for n in self.cluster.nodes][:3]

3
nailgun/nailgun/test/integration/test_task_deploy.py
View File

@ -28,7 +28,7 @@ from nailgun.utils import reverse
class TestTaskDeploy(BaseIntegrationTest):
def setUp(self):
super(TestTaskDeploy, self).setUp()
self.env.create(
self.cluster = self.env.create(
api=False,
nodes_kwargs=[
{"name": "First",
@ -42,7 +42,6 @@ class TestTaskDeploy(BaseIntegrationTest):
'version': '2015.1.0-8.0',
},
)
self.cluster = self.env.clusters[-1]
def add_plugin_with_tasks(self, task_id):
deployment_tasks = self.env.get_default_plugin_deployment_tasks(

6
nailgun/nailgun/test/integration/test_task_logging.py
View File

@ -146,7 +146,7 @@ class TestTasksLogging(BaseIntegrationTest):
@fake_tasks(god_mode=True, recover_nodes=False)
@patch.object(TaskHelper, 'update_action_log')
def test_stop_task_logging(self, logger):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"pending_addition": True, "pending_roles": ["controller"]},
{"pending_addition": True, "pending_roles": ["cinder"]},
@ -161,7 +161,6 @@ class TestTasksLogging(BaseIntegrationTest):
# FIXME(aroma): remove when stop action will be reworked for ha
# cluster. To get more details, please, refer to [1]
# [1]: https://bugs.launchpad.net/fuel/+bug/1529691
cluster = self.env.clusters[0]
objects.Cluster.set_deployed_before_flag(cluster, value=False)
self.env.stop_deployment()
@ -258,7 +257,7 @@ class TestTasksLogging(BaseIntegrationTest):
@fake_tasks()
def test_update_task_logging_on_deployment(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"pending_addition": True, "pending_roles": ["controller"]}
]
@ -274,7 +273,6 @@ class TestTasksLogging(BaseIntegrationTest):
# FIXME(aroma): remove when stop action will be reworked for ha
# cluster. To get more details, please, refer to [1]
# [1]: https://bugs.launchpad.net/fuel/+bug/1529691
cluster = self.env.clusters[0]
objects.Cluster.set_deployed_before_flag(cluster, value=False)
# Stopping deployment

111
nailgun/nailgun/test/integration/test_task_managers.py
View File

@ -102,14 +102,13 @@ class TestTaskManagers(BaseIntegrationTest):
@mock.patch('nailgun.task.task.rpc.cast')
def test_settings_saved_in_transaction(self, _):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"pending_addition": True},
{"pending_deletion": True,
'status': NODE_STATUSES.provisioned},
]
)
cluster = self.env.clusters[-1]
supertask = self.env.launch_deployment(cluster.id)
self.assertNotEqual(TASK_STATUSES.error, supertask.status)
deployment_task = next(
@ -139,7 +138,7 @@ class TestTaskManagers(BaseIntegrationTest):
def check_deployment_info_was_saved_in_transaction(
self, release_ver, is_task_deploy, is_lcm
):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"pending_addition": True},
{"pending_deletion": True,
@ -150,7 +149,6 @@ class TestTaskManagers(BaseIntegrationTest):
'version': release_ver
},
)
cluster = self.env.clusters[-1]
if not is_task_deploy:
self.env.disable_task_deploy(cluster)
@ -183,7 +181,7 @@ class TestTaskManagers(BaseIntegrationTest):
'roles': ['controller'], 'version': '2.1.0',
}
]
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"pending_addition": True, "pending_roles": ['controller']},
{"pending_addition": True, "pending_roles": ['controller']},
@ -193,7 +191,6 @@ class TestTaskManagers(BaseIntegrationTest):
'version': 'mitaka-9.0',
},
)
cluster = self.env.clusters[-1]
supertask = self.env.launch_deployment(cluster.id)
self.assertNotEqual(TASK_STATUSES.error, supertask.status)
tasks_graph = rpc_mock.call_args[0][1][1]['args']['tasks_graph']
@ -367,7 +364,7 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks(fake_rpc=False, mock_rpc=False)
@mock.patch('nailgun.rpc.cast')
def test_update_nodes_info_on_node_removal(self, _):
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'status': consts.CLUSTER_STATUSES.operational,
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
@ -382,7 +379,7 @@ class TestTaskManagers(BaseIntegrationTest):
{'status': consts.NODE_STATUSES.ready, 'roles': ['compute']},
])
objects.Cluster.prepare_for_deployment(self.env.clusters[0])
objects.Cluster.prepare_for_deployment(cluster)
self.env.launch_deployment()
args, _ = nailgun.task.manager.rpc.cast.call_args_list[1]
@ -463,7 +460,7 @@ class TestTaskManagers(BaseIntegrationTest):
# Do not move cluster to error state
# in case if cluster new and before
# validation failed
self.assertEqual(self.env.clusters[0].status, 'new')
self.assertEqual(cluster.status, 'new')
@fake_tasks()
def test_deployment_fails_if_node_to_redeploy_is_offline(self):
@ -491,11 +488,11 @@ class TestTaskManagers(BaseIntegrationTest):
'and try again.'.format(offline_node.full_name))
self.assertEqual(supertask.message, msg)
self.assertEqual(self.env.clusters[0].status, 'error')
self.assertEqual(cluster.status, 'error')
@fake_tasks(override_state={"progress": 100, "status": "ready"})
def test_redeployment_works(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"pending_addition": True},
{"pending_addition": True},
@ -508,7 +505,7 @@ class TestTaskManagers(BaseIntegrationTest):
self.env.refresh_nodes()
self.env.create_node(
cluster_id=self.env.clusters[0].id,
cluster_id=cluster.id,
roles=["controller"],
pending_addition=True
)
@ -546,19 +543,17 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks()
def test_deletion_cluster_task_manager(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"status": "ready", "progress": 100},
{"roles": ["compute"], "status": "ready", "progress": 100},
{"roles": ["compute"], "pending_addition": True},
]
)
cluster_id = self.env.clusters[0].id
cluster_name = self.env.clusters[0].name
resp = self.app.delete(
reverse(
'ClusterHandler',
kwargs={'obj_id': cluster_id}),
kwargs={'obj_id': cluster.id}),
headers=self.default_headers
)
self.assertEqual(202, resp.status_code)
@ -566,9 +561,9 @@ class TestTaskManagers(BaseIntegrationTest):
notification = self.db.query(models.Notification)\
.filter(models.Notification.topic == "done")\
.filter(models.Notification.message == "Environment '%s' and all "
"its nodes are deleted" % cluster_name).first()
"its nodes are deleted" % cluster.name).first()
self.assertIsNotNone(notification)
self.assertIsNone(self.db.query(models.Cluster).get(cluster_id))
self.assertIsNone(self.db.query(models.Cluster).get(cluster.id))
tasks = self.db.query(models.Task).all()
self.assertEqual(len(tasks), 1)
@ -577,7 +572,7 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks(tick_interval=10, tick_count=5)
def test_deletion_clusters_one_by_one(self):
self.env.create(
cluster1 = self.env.create(
nodes_kwargs=[
{"roles": ["compute"], "status": "ready", "progress": 100},
{"roles": ["compute"], "status": "ready", "progress": 100},
@ -587,15 +582,13 @@ class TestTaskManagers(BaseIntegrationTest):
{"roles": ["cinder"], "status": "ready", "progress": 100},
]
)
cluster1_id = self.env.clusters[0].id
self.env.create_cluster(api=True)
cluster2_id = self.env.clusters[1].id
cluster2 = self.env.create_cluster(api=True)
cluster_names = [cluster.name for cluster in self.env.clusters]
resp = self.app.delete(
reverse(
'ClusterHandler',
kwargs={'obj_id': cluster1_id}),
kwargs={'obj_id': cluster1.id}),
headers=self.default_headers
)
self.assertEqual(202, resp.status_code)
@ -603,7 +596,7 @@ class TestTaskManagers(BaseIntegrationTest):
resp = self.app.delete(
reverse(
'ClusterHandler',
kwargs={'obj_id': cluster2_id}),
kwargs={'obj_id': cluster2.id}),
headers=self.default_headers
)
self.assertEqual(202, resp.status_code)
@ -611,8 +604,8 @@ class TestTaskManagers(BaseIntegrationTest):
timer = time.time()
timeout = 15
clstr1 = self.db.query(models.Cluster).get(cluster1_id)
clstr2 = self.db.query(models.Cluster).get(cluster2_id)
clstr1 = self.db.query(models.Cluster).get(cluster1.id)
clstr2 = self.db.query(models.Cluster).get(cluster2.id)
while clstr1 or clstr2:
time.sleep(1)
try:
@ -637,16 +630,15 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks(recover_nodes=False, fake_rpc=False)
def test_deletion_during_deployment(self, mock_rpc):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"status": "ready", "pending_addition": True},
]
)
cluster_id = self.env.clusters[0].id
resp = self.app.put(
reverse(
'ClusterChangesHandler',
kwargs={'cluster_id': cluster_id}),
kwargs={'cluster_id': cluster.id}),
headers=self.default_headers
)
deploy_uuid = resp.json_body['uuid']
@ -659,7 +651,7 @@ class TestTaskManagers(BaseIntegrationTest):
resp = self.app.delete(
reverse(
'ClusterHandler',
kwargs={'obj_id': cluster_id}),
kwargs={'obj_id': cluster.id}),
headers=self.default_headers
)
task_delete = self.db.query(models.Task).filter_by(
@ -676,14 +668,14 @@ class TestTaskManagers(BaseIntegrationTest):
).first()
self.assertIsNone(task_deploy)
task_delete = self.db.query(models.Task).filter_by(
cluster_id=cluster_id,
cluster_id=cluster.id,
name="cluster_deletion"
).first()
self.assertIsNone(task_delete)
@fake_tasks(override_state={"progress": 100, "status": "ready"})
def test_deletion_cluster_ha_3x3(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={
"api": True,
},
@ -692,22 +684,20 @@ class TestTaskManagers(BaseIntegrationTest):
{"roles": ["compute"], "pending_addition": True}
] * 3
)
cluster_id = self.env.clusters[0].id
cluster_name = self.env.clusters[0].name
supertask = self.env.launch_deployment()
self.assertEqual(supertask.status, consts.TASK_STATUSES.ready)
resp = self.app.delete(
reverse(
'ClusterHandler',
kwargs={'obj_id': cluster_id}),
kwargs={'obj_id': cluster.id}),
headers=self.default_headers
)
self.assertEqual(202, resp.status_code)
timer = time.time()
timeout = 15
clstr = self.db.query(models.Cluster).get(cluster_id)
clstr = self.db.query(models.Cluster).get(cluster.id)
while clstr:
time.sleep(1)
try:
@ -720,7 +710,7 @@ class TestTaskManagers(BaseIntegrationTest):
notification = self.db.query(models.Notification)\
.filter(models.Notification.topic == "done")\
.filter(models.Notification.message == "Environment '%s' and all "
"its nodes are deleted" % cluster_name).first()
"its nodes are deleted" % cluster.name).first()
self.assertIsNotNone(notification)
tasks = self.db.query(models.Task).all()
@ -752,16 +742,15 @@ class TestTaskManagers(BaseIntegrationTest):
@mock.patch.object(task.DeletionTask, 'execute')
def test_deletion_task_called(self, mdeletion_execute):
cluster = self.env.create_cluster()
cluster_id = cluster['id']
node_db = self.env.create_node(
api=False,
cluster_id=cluster['id'],
cluster_id=cluster.id,
pending_addition=False,
pending_deletion=True,
status=NODE_STATUSES.ready,
roles=['controller'])
manager_ = manager.ApplyChangesTaskManager(cluster_id)
manager_ = manager.ApplyChangesTaskManager(cluster.id)
manager_.execute()
self.assertEqual(mdeletion_execute.call_count, 1)
@ -782,16 +771,15 @@ class TestTaskManagers(BaseIntegrationTest):
@mock.patch.object(task.DeletionTask, 'execute')
def test_deletion_task_w_check_ceph(self, mdeletion_execute):
cluster = self.env.create_cluster()
cluster_id = cluster['id']
self.env.create_node(
api=False,
cluster_id=cluster['id'],
cluster_id=cluster.id,
pending_addition=False,
pending_deletion=True,
status=NODE_STATUSES.ready,
roles=['controller'])
manager_ = manager.ApplyChangesTaskManager(cluster_id)
manager_ = manager.ApplyChangesTaskManager(cluster.id)
manager_.execute()
self.assertEqual(mdeletion_execute.call_count, 1)
@ -846,12 +834,11 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks()
@mock.patch('nailgun.task.manager.tasks.DeletionTask.execute')
def test_apply_changes_exception_caught(self, mdeletion_execute):
self.env.create(
cluster_db = self.env.create(
nodes_kwargs=[
{"pending_deletion": True, "status": NODE_STATUSES.ready},
]
)
cluster_db = self.env.clusters[0]
objects.Cluster.clear_pending_changes(cluster_db)
manager_ = manager.ApplyChangesTaskManager(cluster_db.id)
mdeletion_execute.side_effect = Exception('exception')
@ -860,14 +847,14 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks(recover_offline_nodes=False)
def test_deletion_offline_node(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"online": False, "pending_deletion": True},
{"status": "ready"}
]
)
to_delete = TaskHelper.nodes_to_delete(self.env.clusters[0])
to_delete = TaskHelper.nodes_to_delete(cluster)
to_delete_ids = [node.id for node in to_delete]
self.assertEqual(len(to_delete_ids), 1)
@ -942,7 +929,7 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks(recover_offline_nodes=False)
def test_deletion_offline_node_when_cluster_has_only_one_node(self):
cluster = self.env.create_cluster()
objects.Cluster.clear_pending_changes(self.env.clusters[0])
objects.Cluster.clear_pending_changes(cluster)
self.env.create_node(
cluster_id=cluster['id'],
online=False,
@ -957,12 +944,11 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks(recover_nodes=False)
def test_node_deletion_task_manager(self):
self.env.create(
cluster_db = self.env.create(
nodes_kwargs=[
{"pending_deletion": True, "status": "ready"}
]
)
cluster_db = self.env.clusters[0]
objects.Cluster.clear_pending_changes(cluster_db)
manager_ = manager.NodeDeletionTaskManager(cluster_id=cluster_db.id)
task = manager_.execute(cluster_db.nodes)
@ -973,12 +959,11 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks(recover_nodes=False)
def test_node_deletion_task_mgr_works_for_nodes_not_in_cluster(self):
self.env.create(
cluster_db = self.env.create(
nodes_kwargs=[
{"pending_deletion": True, "status": "ready"}
]
)
cluster_db = self.env.clusters[0]
objects.Cluster.clear_pending_changes(cluster_db)
node = cluster_db.nodes[0]
objects.Node.update(node, {'cluster_id': None})
@ -993,12 +978,11 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks(recover_nodes=False)
def test_node_deletion_task_manager_invalid_cluster(self):
self.env.create(
cluster_db = self.env.create(
nodes_kwargs=[
{"pending_deletion": True, "status": "ready"}
]
)
cluster_db = self.env.clusters[0]
objects.Cluster.clear_pending_changes(cluster_db)
manager_ = manager.NodeDeletionTaskManager()
@ -1008,13 +992,12 @@ class TestTaskManagers(BaseIntegrationTest):
@mock.patch('nailgun.task.manager.rpc.cast')
def test_node_deletion_redeploy_started_for_proper_controllers(self,
mcast):
self.env.create(nodes_kwargs=[
cluster_db = self.env.create(nodes_kwargs=[
{'roles': ['controller'],
'status': consts.NODE_STATUSES.provisioned},
{'roles': ['controller'],
'status': consts.NODE_STATUSES.discover},
])
cluster_db = self.env.clusters[0]
node_to_delete = self.env.create_node(
cluster_id=cluster_db.id,
@ -1036,11 +1019,10 @@ class TestTaskManagers(BaseIntegrationTest):
self.assertEqual(node_to_deploy.uid, depl_info[0]['uid'])
def test_node_deletion_task_failed_with_controller_in_error(self):
self.env.create(nodes_kwargs=[
cluster_db = self.env.create(nodes_kwargs=[
{'roles': ['controller'],
'status': consts.NODE_STATUSES.error},
])
cluster_db = self.env.clusters[0]
node_to_delete = self.env.create_node(
cluster_id=cluster_db.id,
@ -1054,7 +1036,7 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks()
def test_deployment_on_controller_removal_via_apply_changes(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller'],
'pending_deletion': True},
@ -1071,7 +1053,6 @@ class TestTaskManagers(BaseIntegrationTest):
]
)
cluster = self.env.clusters[0]
expected_nodes_to_deploy = filter(lambda n: 'controller' in n.roles
and not n.pending_deletion,
cluster.nodes)
@ -1086,7 +1067,7 @@ class TestTaskManagers(BaseIntegrationTest):
@fake_tasks()
def test_deployment_on_controller_removal_via_node_deletion(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller'],
'status': consts.NODE_STATUSES.ready},
@ -1101,7 +1082,6 @@ class TestTaskManagers(BaseIntegrationTest):
]
)
cluster = self.env.clusters[0]
controllers = filter(lambda n: 'controller' in n.roles
and not n.pending_deletion,
cluster.nodes)
@ -1124,10 +1104,10 @@ class TestTaskManagers(BaseIntegrationTest):
@mock.patch('nailgun.rpc.cast')
def test_delete_nodes_do_not_run_if_there_is_deletion_running(self, _):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[{'roles': ['controller']}] * 3)
self.task_manager = manager.NodeDeletionTaskManager(
cluster_id=self.env.clusters[0].id)
cluster_id=cluster.id)
self.task_manager.execute(self.env.nodes)
self.assertRaisesRegexp(
@ -1138,10 +1118,9 @@ class TestTaskManagers(BaseIntegrationTest):
@mock.patch('nailgun.rpc.cast')
def test_delete_nodes_reelection_if_primary_for_deletion(self, _):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[{'roles': ['controller'],
'status': consts.NODE_STATUSES.ready}] * 3)
cluster = self.env.clusters[0]
task_manager = manager.NodeDeletionTaskManager(cluster_id=cluster.id)
objects.Cluster.set_primary_roles(cluster, self.env.nodes)
primary_node = filter(

49
nailgun/nailgun/test/integration/test_verify_networks_task_manager.py
View File

@ -39,14 +39,13 @@ class TestVerifyNetworkTaskManagers(BaseIntegrationTest):
mac1 = meta1['interfaces'][0]['mac']
mac2 = meta2['interfaces'][0]['mac']
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron},
nodes_kwargs=[
{"api": True, "meta": meta1, "mac": mac1},
{"api": True, "meta": meta2, "mac": mac2},
])
self.cluster = self.env.clusters[0]
@fake_tasks()
def test_network_verify_task_managers_dhcp_on_master(self):
@ -151,12 +150,11 @@ class TestVerifyNetworkTaskManagers(BaseIntegrationTest):
@fake_tasks()
def test_network_verify_when_env_not_ready(self):
cluster_db = self.env.clusters[0]
blocking_statuses = (
consts.CLUSTER_STATUSES.deployment,
)
for status in blocking_statuses:
cluster_db.status = status
self.cluster.status = status
self.db.flush()
resp = self.env.neutron_networks_get(self.cluster.id)
@ -204,9 +202,9 @@ class TestVerifyNetworkTaskManagers(BaseIntegrationTest):
@unittest2.skip('Multicast is always disabled.')
@fake_tasks(fake_rpc=False)
def test_multicast_disabled_when_corosync_is_not_present(self, mocked_rpc):
editable = copy.deepcopy(self.env.clusters[0].attributes.editable)
editable = copy.deepcopy(self.cluster.attributes.editable)
del editable['corosync']
self.env.clusters[0].attributes.editable = editable
self.cluster.attributes.editable = editable
self.env.launch_verify_networks()
self.assertIn('subtasks', mocked_rpc.call_args[0][1])
subtasks = mocked_rpc.call_args[0][1]['subtasks']
@ -235,7 +233,7 @@ class TestVerifyNetworksDisabled(BaseIntegrationTest):
"max_speed": 1000,
"name": "eth2",
"current_speed": None}])
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={'status': consts.CLUSTER_STATUSES.operational,
'net_provider': 'neutron',
'net_segment_type': 'vlan'},
@ -248,7 +246,6 @@ class TestVerifyNetworksDisabled(BaseIntegrationTest):
},
]
)
self.cluster = self.env.clusters[0]
@fake_tasks()
def test_network_verification_neutron_with_vlan_segmentation(self):
@ -274,7 +271,7 @@ class TestNetworkVerificationWithBonds(BaseIntegrationTest):
{"name": "eth1", "mac": "00:00:00:00:22:77", "current_speed": 100},
{"name": "eth2", "mac": "00:00:00:00:33:88", "current_speed": 100}]
)
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
'net_segment_type': 'gre'
@ -380,14 +377,14 @@ class TestNetworkVerificationWithBonds(BaseIntegrationTest):
resp = self.app.get(
reverse(
'NeutronNetworkConfigurationHandler',
kwargs={'cluster_id': self.env.clusters[0].id}
kwargs={'cluster_id': self.cluster.id}
),
headers=self.default_headers
)
resp = self.app.put(
reverse(
'NeutronNetworkConfigurationVerifyHandler',
kwargs={'cluster_id': self.env.clusters[0].id}),
kwargs={'cluster_id': self.cluster.id}),
resp.body,
headers=self.default_headers,
expect_errors=True
@ -789,12 +786,11 @@ class TestVerifyNovaFlatDHCP(BaseIntegrationTest):
}
)
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.nova_network},
nodes_kwargs=nodes_kwargs,
)
self.cluster = self.env.clusters[0]
@fake_tasks()
def test_flat_dhcp_verify(self):
@ -828,7 +824,7 @@ class TestVerifyNeutronVlan(BaseIntegrationTest):
{"name": "eth0", "mac": "00:00:00:00:01:66"},
{"name": "eth1", "mac": "00:00:00:00:01:77"},
{"name": "eth2", "mac": "00:00:00:00:01:88"}])
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
'net_segment_type': 'vlan'
@ -850,23 +846,22 @@ class TestVerifyNeutronVlan(BaseIntegrationTest):
@fake_tasks()
def test_verify_networks_after_stop(self):
cluster = self.env.clusters[0]
deploy_task = self.env.launch_deployment()
self.assertEqual(deploy_task.status, consts.TASK_STATUSES.ready)
# FIXME(aroma): remove when stop action will be reworked for ha
# cluster. To get more details, please, refer to [1]
# [1]: https://bugs.launchpad.net/fuel/+bug/1529691
objects.Cluster.set_deployed_before_flag(cluster, value=False)
objects.Cluster.set_deployed_before_flag(self.cluster, value=False)
stop_task = self.env.stop_deployment()
self.assertEqual(stop_task.status, consts.TASK_STATUSES.ready)
self.db.refresh(cluster)
self.assertEqual(cluster.status, consts.CLUSTER_STATUSES.stopped)
self.assertFalse(cluster.is_locked)
self.db.refresh(self.cluster)
self.assertEqual(self.cluster.status, consts.CLUSTER_STATUSES.stopped)
self.assertFalse(self.cluster.is_locked)
# Moving nodes online by hands. Our fake threads do this with
# random success
for node in sorted(cluster.nodes, key=lambda n: n.id):
for node in sorted(self.cluster.nodes, key=lambda n: n.id):
node.online = True
self.db.commit()
verify_task = self.env.launch_verify_networks()
@ -876,7 +871,7 @@ class TestVerifyNeutronVlan(BaseIntegrationTest):
def test_network_verification_neutron_with_vlan_segmentation(
self, mocked_rpc):
# get Neutron L2 VLAN ID range
vlan_rng_be = self.env.clusters[0].network_config.vlan_range
vlan_rng_be = self.cluster.network_config.vlan_range
vlan_rng = set(range(vlan_rng_be[0], vlan_rng_be[1] + 1))
# get nodes NICs for private network
@ -902,13 +897,13 @@ class TestVerifyNeutronVlan(BaseIntegrationTest):
@fake_tasks()
def test_network_verification_parameters_w_one_node_having_public(self):
# Decrease VLAN range and set public VLAN
resp = self.env.neutron_networks_get(self.env.clusters[0].id)
resp = self.env.neutron_networks_get(self.cluster.id)
nets = resp.json_body
nets['networking_parameters']['vlan_range'] = [1000, 1004]
for net in nets['networks']:
if net['name'] == consts.NETWORKS.public:
net['vlan_start'] = 333
resp = self.env.neutron_networks_put(self.env.clusters[0].id, nets)
resp = self.env.neutron_networks_put(self.cluster.id, nets)
self.assertEqual(resp.status_code, 200)
task = self.env.launch_verify_networks()
@ -928,15 +923,15 @@ class TestVerifyNeutronVlan(BaseIntegrationTest):
api=True,
pending_addition=True,
roles=['controller'],
cluster_id=self.env.clusters[0].id)
cluster_id=self.cluster.id)
# Decrease VLAN range and set public VLAN
resp = self.env.neutron_networks_get(self.env.clusters[0].id)
resp = self.env.neutron_networks_get(self.cluster.id)
nets = resp.json_body
nets['networking_parameters']['vlan_range'] = [1000, 1004]
for net in nets['networks']:
if net['name'] == consts.NETWORKS.public:
net['vlan_start'] = 333
resp = self.env.neutron_networks_put(self.env.clusters[0].id, nets)
resp = self.env.neutron_networks_put(self.cluster.id, nets)
self.assertEqual(resp.status_code, 200)
task = self.env.launch_verify_networks()
@ -974,7 +969,7 @@ class TestVerifyNeutronVlan(BaseIntegrationTest):
@fake_tasks()
def test_repo_availability_tasks_are_not_created(self):
self.env.clusters[0].release.version = '2014.1-6.0'
self.cluster.release.version = '2014.1-6.0'
self.db.flush()
task = self.env.launch_verify_networks()

3
nailgun/nailgun/test/unit/fuel_statistics_tests/test_client_provider.py
View File

@ -91,10 +91,9 @@ class TestOpenStackClientProvider(BaseTestCase):
get_kc_mock.assert_called_once_with(auth_kwargs)
def test_fail_if_no_online_controllers(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[{"online": False, "roles": ["controller"]}]
)
cluster = self.env.clusters[0]
client_provider = helpers.ClientProvider(cluster)
with self.assertRaises(errors.NoOnlineControllers):

20
nailgun/nailgun/test/unit/fuel_statistics_tests/test_installation_info.py
View File

@ -139,15 +139,15 @@ class TestInstallationInfo(BaseTestCase):
{'roles': ['compute']},
{'roles': ['controller']}
]
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'release_id': release[0].id,
'mode': consts.CLUSTER_MODES.ha_compact,
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron},
nodes_kwargs=nodes_params
)
self.env.create_node({'status': consts.NODE_STATUSES.discover})
cluster = self.env.clusters[0]
self.env.create_node(
{'status': consts.NODE_STATUSES.discover})
VmwareAttributes.delete(cluster.vmware_attributes)
self.env.db.flush()
self.assertNotRaises(AttributeError, info.get_clusters_info)
@ -162,16 +162,16 @@ class TestInstallationInfo(BaseTestCase):
{'roles': ['compute']},
{'roles': ['controller']}
]
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'release_id': release[0].id,
'mode': consts.CLUSTER_MODES.ha_compact,
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron},
nodes_kwargs=nodes_params
)
self.env.create_node({'status': consts.NODE_STATUSES.discover})
self.env.create_node(
{'status': consts.NODE_STATUSES.discover})
clusters_info = info.get_clusters_info()
cluster = self.env.clusters[0]
self.assertEquals(1, len(clusters_info))
cluster_info = clusters_info[0]
@ -187,7 +187,7 @@ class TestInstallationInfo(BaseTestCase):
self.assertEquals(False,
cluster_info['is_customized'])
self.assertEquals(cluster.id,
self.assertEquals(cluster['id'],
cluster_info['id'])
self.assertEquals(cluster.fuel_version,
cluster_info['fuel_version'])
@ -442,10 +442,9 @@ class TestInstallationInfo(BaseTestCase):
return filter(lambda x: x not in private_paths, leafs_paths)
def test_all_cluster_attributes_in_white_list(self):
self.env.create(nodes_kwargs=[{'roles': ['compute']}])
cluster = self.env.create(nodes_kwargs=[{'roles': ['compute']}])
self.env.create_node(status=consts.NODE_STATUSES.discover)
cluster = self.env.clusters[0]
expected_paths = self._find_leafs_paths(cluster.attributes.editable)
# Removing 'value' from expected paths
@ -460,10 +459,9 @@ class TestInstallationInfo(BaseTestCase):
self.assertIn(path, actual_paths)
def test_all_cluster_vmware_attributes_in_white_list(self):
self.env.create(nodes_kwargs=[{'roles': ['compute']}])
cluster = self.env.create(nodes_kwargs=[{'roles': ['compute']}])
self.env.create_node(status=consts.NODE_STATUSES.discover)
cluster = self.env.clusters[0]
expected_paths = self._find_leafs_paths(
cluster.vmware_attributes.editable,
leafs_names=('vsphere_cluster', 'enable'))

3
nailgun/nailgun/test/unit/fuel_statistics_tests/test_oswl_saver.py
View File

@ -276,8 +276,7 @@ class TestOSWLServerInfoSaving(BaseTestCase):
self.assertEqual(False, last_changed.is_sent)
def test_oswl_statistics_save_version_info(self):
self.env.create()
cluster = self.env.clusters[0]
cluster = self.env.create()
# Without version info
oswl_statistics_save(cluster.id, consts.OSWL_RESOURCE_TYPES.vm, [])

6
nailgun/nailgun/test/unit/fuel_statistics_tests/test_utils_functions.py
View File

@ -99,13 +99,12 @@ class TestUtilsFunctions(BaseTestCase):
def test_get_online_controller(self):
node_name = "test"
self.env.create(
cluster = self.env.create(
nodes_kwargs=[{"online": True,
"roles": ["controller"],
"name": node_name}]
)
cluster = self.env.clusters[0]
online_controller = utils.get_online_controller(cluster)
self.assertIsNotNone(online_controller)
self.assertEqual(online_controller.name, node_name)
@ -140,8 +139,7 @@ class TestUtilsFunctions(BaseTestCase):
def test_get_version_info(self):
self.assertIsNone(utils.get_version_info(None))
self.env.create()
cluster = self.env.clusters[0]
cluster = self.env.create()
version_info = utils.get_version_info(cluster)
self.assertItemsEqual(
('release_os', 'release_name', 'release_version',

3
nailgun/nailgun/test/unit/test_check_repo_connection_task.py
View File

@ -25,7 +25,7 @@ class TestRepoAvailability(BaseTestCase):
def setUp(self):
super(TestRepoAvailability, self).setUp()
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
'net_provider': 'neutron',
'net_segment_type': 'gre'
@ -35,7 +35,6 @@ class TestRepoAvailability(BaseTestCase):
{'roles': ['compute']},
{'roles': ['compute'], 'online': False}])
self.cluster = self.env.clusters[0]
self.public_ng = next(ng for ng in self.cluster.network_groups
if ng.name == 'public')
self.free_ips = NetworkManager.get_free_ips(self.public_ng, 2)

18
nailgun/nailgun/test/unit/test_deadlock_detector.py
View File

@ -250,7 +250,7 @@ class TestDeadlockDetector(BaseTestCase):
db().query(models.Node).with_lockmode('update').get(nodes[1].id)
def test_updating_already_locked_object(self):
self.env.create_cluster()
cluster = self.env.create_cluster()
self.env.create_nodes(2)
self.env.create_cluster()
self.assertGreater(len(self.env.clusters), 1)
@ -261,17 +261,15 @@ class TestDeadlockDetector(BaseTestCase):
db().query(models.Node).order_by('id').with_lockmode('update').all()
# Lock is allowed
cluster = self.env.clusters[0]
cluster.status = consts.CLUSTER_STATUSES.error
def test_id_traced_on_updating_object(self):
self.env.create_cluster()
cluster = self.env.create_cluster()
self.env.create_nodes(2)
self.env.create_cluster()
self.assertGreater(len(self.env.clusters), 1)
# Updating cluster
cluster = self.env.clusters[0]
cluster.status = consts.CLUSTER_STATUSES.error
# Checking locked id trace
@ -296,13 +294,12 @@ class TestDeadlockDetector(BaseTestCase):
node.status = consts.NODE_STATUSES.error
def test_lock_ids_in_non_last_lock_failed(self):
self.env.create_cluster()
cluster = self.env.create_cluster()
self.env.create_nodes(2)
self.env.create_cluster()
another_cluster = self.env.create_cluster()
self.assertGreater(len(self.env.clusters), 1)
# Tracing cluster modification
cluster = self.env.clusters[0]
cluster.status = consts.CLUSTER_STATUSES.error
cluster_lock = dd.find_lock(models.Cluster.__tablename__)
@ -314,7 +311,6 @@ class TestDeadlockDetector(BaseTestCase):
# Trying to lock ids in non last lock
last_lock = dd.context.locks[-1]
self.assertNotEqual(cluster_lock, last_lock)
another_cluster = self.env.clusters[1]
with self.assertRaises(dd.TablesLockingOrderViolation):
another_cluster.status = consts.CLUSTER_STATUSES.error
@ -433,12 +429,10 @@ class TestDeadlockDetector(BaseTestCase):
db().delete(nodes[1])
def test_deletion_with_non_last_lock_failed(self):
self.env.create_cluster()
old_cluster = self.env.create_cluster()
self.env.create_nodes(2)
old_cluster = self.env.clusters[0]
self.env.create_cluster()
new_cluster = self.env.clusters[1]
new_cluster = self.env.create_cluster()
# Locking clusters and nodes
db().query(models.Cluster).with_lockmode('update').\

6
nailgun/nailgun/test/unit/test_deployment_graph_object.py
View File

@ -181,8 +181,7 @@ class TestDeploymentGraphModel(
expected_updated_tasks, serialized['tasks'])
def test_deployment_graph_delete(self):
self.env.create()
cluster = self.env.clusters[-1]
cluster = self.env.create()
deployment_graph.DeploymentGraph.create_for_model(
{'tasks': JSON_TASKS, 'name': 'test_graph'}, cluster, 'test_graph'
)
@ -197,8 +196,7 @@ class TestDeploymentGraphModel(
self.assertIsNone(dg)
def test_deployment_graph_create_for_model(self):
self.env.create()
cluster = self.env.clusters[-1]
cluster = self.env.create()
deployment_graph.DeploymentGraph.create_for_model(
{'tasks': JSON_TASKS, 'name': 'test_graph'}, cluster, 'test_graph'
)

3
nailgun/nailgun/test/unit/test_deployment_network_serializer.py
View File

@ -26,11 +26,10 @@ class BaseTestNeutronDeploymentSerializer(base.BaseTestCase):
def setUp(self):
super(BaseTestNeutronDeploymentSerializer, self).setUp()
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={'net_provider': 'neutron'},
release_kwargs={'version': self.env_version}
)
self.cluster = self.env.clusters[0]
def check_shared_attrs_of_external_network(self, external_net):
self.assertEqual(

6
nailgun/nailgun/test/unit/test_deployment_nodes_filtering.py
View File

@ -22,7 +22,7 @@ class TestDeploymentNodesFiltering(BaseIntegrationTest):
def setUp(self):
super(TestDeploymentNodesFiltering, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={
'version': 'liberty-8.0'
},
@ -37,13 +37,13 @@ class TestDeploymentNodesFiltering(BaseIntegrationTest):
)
def test_related_pending_deletion_nodes_not_present(self):
cluster = self.env.clusters[0]
cluster = self.cluster
controllers = [n for n in cluster.nodes if 'controller' in n.all_roles]
nodes_to_deploy = TaskHelper.nodes_to_deploy(cluster)
self.assertItemsEqual(controllers, nodes_to_deploy)
def test_related_pending_deletion_nodes_not_present_with_force(self):
cluster = self.env.clusters[0]
cluster = self.cluster
controllers = [n for n in cluster.nodes if 'controller' in n.all_roles]
nodes_to_deploy = TaskHelper.nodes_to_deploy(cluster, force=True)
self.assertItemsEqual(controllers, nodes_to_deploy)

6
nailgun/nailgun/test/unit/test_extensions.py
View File

@ -211,11 +211,10 @@ class TestPipeline(BaseExtensionCase):
{'roles': ['controller'], 'pending_addition': True},
]
self.env.create(
cluster = self.env.create(
cluster_kwargs={'api': False},
nodes_kwargs=nodes_kwargs)
cluster = self.env.clusters[0]
cluster.extensions = [self.extension.name, 'volume_manager']
self.db.flush()
@ -352,11 +351,10 @@ class TestPipeline(BaseExtensionCase):
mfire_callback.call_args[0][2], cluster.nodes[1:])
def test_pipeline_change_data(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'api': False},
nodes_kwargs=[{'roles': ['controller'], 'pending_addition': True}]
)
cluster = self.env.clusters[0]
cluster.extensions = [self.extension.name]
self.db.flush()

3
nailgun/nailgun/test/unit/test_logs_handlers.py
View File

@ -152,8 +152,7 @@ class TestLogs(BaseIntegrationTest):
'text2',
],
]
self.env.create_cluster()
cluster = self.env.clusters[0]
cluster = self.env.create_cluster()
node = self.env.create_node(cluster_id=cluster.id, ip=node_ip)
self._create_logfile_for_node(settings.LOGS[0], log_entries)
self._create_logfile_for_node(settings.LOGS[1], log_entries, node)

3
nailgun/nailgun/test/unit/test_migration_cluster_replaced_info.py
View File

@ -20,13 +20,12 @@ class TestReplacedDataMigration(BaseIntegrationTest):
def setUp(self):
super(TestReplacedDataMigration, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller'], 'pending_addition': True},
{'roles': ['controller', 'cinder'], 'pending_addition': True},
]
)
self.cluster = self.env.clusters[0]
self.nodes = self.env.nodes
self.deployment_info = []
self.provisioning_info = {'nodes': [], 'engine': {'custom': 'type'}}

3
nailgun/nailgun/test/unit/test_migration_plugins_cluster_attrs_use_ids_mapping.py
View File

@ -24,8 +24,7 @@ class TestMigrationPluginsClusterAttrs(BaseTestCase):
def setUp(self):
super(TestMigrationPluginsClusterAttrs, self).setUp()
self.env.create()
self.cluster = self.env.clusters[0]
self.cluster = self.env.create()
self.plugins = [
Plugin.create(self.env.get_default_plugin_metadata(
name='plugin_name_1')),

7
nailgun/nailgun/test/unit/test_network_check.py
View File

@ -37,14 +37,14 @@ class TestNetworkCheck(BaseIntegrationTest):
def setUp(self):
super(TestNetworkCheck, self).setUp()
self.env.create(
cluster = self.env.create(
cluster_kwargs={},
nodes_kwargs=[
{"api": True,
"pending_addition": True},
]
)
self.task = FakeTask(self.env.clusters[0])
self.task = FakeTask(cluster)
@patch.object(helpers, 'db')
def test_check_untagged_intersection_failed(self, mocked_db):
@ -717,7 +717,7 @@ class TestCheckVIPsNames(BaseIntegrationTest):
def setUp(self):
super(TestCheckVIPsNames, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={'version': 'liberty-8.0'},
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
@ -726,7 +726,6 @@ class TestCheckVIPsNames(BaseIntegrationTest):
nodes_kwargs=[{'roles': ['controller']}]
)
self.cluster = self.env.clusters[0]
self.plugin = self.env.create_plugin(cluster=self.cluster)
self.task = Task(cluster_id=self.cluster.id)
self.db.add(self.task)

8
nailgun/nailgun/test/unit/test_network_configuration_validator.py
View File

@ -339,7 +339,7 @@ class TestNetworkConfigurationValidator(base.BaseIntegrationTest):
str(netaddr.IPAddress(node_ip) + 10)]]
resp_neutron_net = self.env.neutron_networks_put(
self.env.clusters[0].id,
self.cluster.id,
self.config,
expect_errors=True)
self.assertEqual(400, resp_neutron_net.status_code)
@ -353,7 +353,7 @@ class TestNetworkConfigurationValidator(base.BaseIntegrationTest):
str(netaddr.IPAddress(node_ip) + 10)]]
resp_neutron_net = self.env.neutron_networks_put(
self.env.clusters[0].id,
self.cluster.id,
self.config)
self.assertEqual(200, resp_neutron_net.status_code)
@ -363,7 +363,7 @@ class TestNetworkConfigurationValidator(base.BaseIntegrationTest):
str(netaddr.IPAddress(node_ip) + 9)]]
resp_neutron_net = self.env.neutron_networks_put(
self.env.clusters[0].id,
self.cluster.id,
self.config,
expect_errors=True)
self.assertEqual(400, resp_neutron_net.status_code)
@ -549,7 +549,7 @@ class TestNeutronNetworkConfigurationValidatorProtocol(
)
self.nc['networking_parameters'].pop('segmentation_type')
serialized_data = self.serialize(self.nc)
self.validator(serialized_data, self.env.clusters[0])
self.validator(serialized_data, self.cluster)
# networking parameters
def test_networking_parameters_additional_property(self):

9
nailgun/nailgun/test/unit/test_node_assignment_handler.py
View File

@ -38,7 +38,7 @@ class TestAssignmentHandlers(BaseIntegrationTest):
)
def test_assignment(self):
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={"api": True},
nodes_kwargs=[
{
@ -47,7 +47,6 @@ class TestAssignmentHandlers(BaseIntegrationTest):
}
]
)
self.cluster = self.env.clusters[0]
node = self.env.nodes[0]
assignment_data = [
{
@ -162,7 +161,7 @@ class TestAssignmentHandlers(BaseIntegrationTest):
self.assertEquals(404, resp.status_code)
def test_assign_conflicting_roles(self):
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={"api": True},
nodes_kwargs=[
{
@ -171,7 +170,6 @@ class TestAssignmentHandlers(BaseIntegrationTest):
}
]
)
self.cluster = self.env.clusters[0]
node = self.env.nodes[0]
assignment_data = [
{
@ -197,7 +195,7 @@ class TestAssignmentHandlers(BaseIntegrationTest):
release = self.env.create_release()
resp = self.env.create_role(release.id, ROLE)
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
"api": True,
"release_id": release.id
@ -209,7 +207,6 @@ class TestAssignmentHandlers(BaseIntegrationTest):
}
]
)
self.cluster = self.env.clusters[0]
node = self.env.nodes[0]
assignment_data = [
{

7
nailgun/nailgun/test/unit/test_node_groups.py
View File

@ -495,8 +495,7 @@ class TestNodeGroups(BaseIntegrationTest):
self.assertRegexpMatches(message, 'Cannot assign node group')
def test_default_group_created_at_cluster_creation(self):
self.env.create_cluster()
cluster = self.env.clusters[0]
cluster = self.env.create_cluster()
self.assertTrue(cluster.node_groups[0].is_default)
@patch('nailgun.task.task.rpc.cast')
@ -524,7 +523,7 @@ class TestNodeGroups(BaseIntegrationTest):
def test_intersecting_ip_deleted_after_nodegroup_is_created(self):
net_roles = copy.copy(
self.env.clusters[0].release.network_roles_metadata)
self.cluster.release.network_roles_metadata)
net_roles.append({
'id': 'stor/vip',
'default_mapping': consts.NETWORKS.storage,
@ -536,7 +535,7 @@ class TestNodeGroups(BaseIntegrationTest):
'node_roles': ['controller'],
}]
}})
self.env.clusters[0].release.network_roles_metadata = net_roles
self.cluster.release.network_roles_metadata = net_roles
self.db.flush()
# allocate VIPs

4
nailgun/nailgun/test/unit/test_object_plugin.py
View File

@ -48,7 +48,7 @@ class ExtraFunctions(base.BaseTestCase):
return plugin_ids
def _create_test_cluster(self):
self.env.create(
return self.env.create(
cluster_kwargs={'mode': consts.CLUSTER_MODES.multinode},
release_kwargs={
'name': uuid.uuid4().get_hex(),
@ -57,8 +57,6 @@ class ExtraFunctions(base.BaseTestCase):
'modes': [consts.CLUSTER_MODES.multinode,
consts.CLUSTER_MODES.ha_compact]})
return self.env.clusters[0]
class TestPluginCollection(ExtraFunctions):

101
nailgun/nailgun/test/unit/test_objects.py
View File

@ -278,13 +278,13 @@ class TestNodeObject(BaseIntegrationTest):
def test_get_kernel_params_overwriten(self):
"""Test verifies that overwriten kernel params will be returned."""
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{"role": "controller"}
])
additional_kernel_params = 'intel_iommu=true'
default_kernel_params = objects.Cluster.get_default_kernel_params(
self.env.clusters[0])
cluster)
kernel_params = '{0} {1}'.format(default_kernel_params,
additional_kernel_params)
self.env.nodes[0].kernel_params = kernel_params
@ -305,13 +305,12 @@ class TestNodeObject(BaseIntegrationTest):
'pending_addition': True},
{'roles': [], 'pending_roles': ['controller'],
'pending_addition': True}]
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
},
nodes_kwargs=nodes)
cluster = self.env.clusters[0]
cluster.release.roles_metadata['mongo']['public_ip_required'] = True
attrs = cluster.attributes.editable
self.assertFalse(
@ -336,14 +335,14 @@ class TestNodeObject(BaseIntegrationTest):
self.assertEqual(nodes_w_public_count, len(nodes))
def test_should_have_public_with_ip_with_given_metadata(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
},
nodes_kwargs=[{}, {}])
node = self.env.nodes[0]
roles_metadata = objects.Cluster.get_roles(self.env.clusters[0])
roles_metadata = objects.Cluster.get_roles(cluster)
with mock.patch.object(objects.Cluster, 'get_roles') as get_roles_mock:
get_roles_mock.return_value = roles_metadata
objects.Node.should_have_public_with_ip(node)
@ -363,13 +362,12 @@ class TestNodeObject(BaseIntegrationTest):
'pending_addition': True},
{'roles': [], 'pending_roles': ['controller'],
'pending_addition': True}]
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
},
nodes_kwargs=nodes)
cluster = self.env.clusters[0]
attrs = copy.deepcopy(cluster.attributes.editable)
attrs['neutron_advanced_configuration']['neutron_dvr']['value'] = True
resp = self.app.patch(
@ -693,7 +691,7 @@ class TestTaskObject(BaseIntegrationTest):
def setUp(self):
super(TestTaskObject, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller']},
{'roles': ['compute']},
@ -708,10 +706,6 @@ class TestTaskObject(BaseIntegrationTest):
for node in nodes:
self.assertEquals(node.status, consts.NODE_STATUSES.discover)
@property
def cluster(self):
return self.env.clusters[0]
def test_update_nodes_to_error_if_deployment_task_failed(self):
self.cluster.nodes[0].status = consts.NODE_STATUSES.deploying
self.cluster.nodes[0].progress = 12
@ -914,12 +908,11 @@ class TestTaskObject(BaseIntegrationTest):
class TestTransactionObject(BaseIntegrationTest):
def setUp(self):
super(TestTransactionObject, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller']},
{'roles': ['compute']},
{'roles': ['cinder']}])
self.cluster = self.env.clusters[-1]
def test_get_last_success_run(self):
objects.Transaction.create({
@ -1094,14 +1087,13 @@ class TestClusterObject(BaseTestCase):
def setUp(self):
super(TestClusterObject, self).setUp()
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={'net_provider': 'neutron'},
nodes_kwargs=[
{'roles': ['controller']},
{'roles': ['controller']},
{'roles': ['compute']},
{'roles': ['cinder']}])
self.cluster = self.env.clusters[0]
def _create_cluster_with_plugins(self, plugins_kw_list):
cluster = self.env.create_cluster(api=False)
@ -1188,17 +1180,16 @@ class TestClusterObject(BaseTestCase):
'nailgun.objects.cluster.'
'fire_callback_on_node_collection_delete')
def test_delete(self, mock_node_coll_delete_cb, mock_cluster_delete_cb):
cluster = self.env.clusters[0]
ids = [node.id for node in cluster.nodes]
objects.Cluster.delete(cluster)
ids = [node.id for node in self.cluster.nodes]
objects.Cluster.delete(self.cluster)
mock_node_coll_delete_cb.assert_called_once_with(ids)
mock_cluster_delete_cb.assert_called_once_with(cluster)
mock_cluster_delete_cb.assert_called_once_with(self.cluster)
self.assertEqual(self.db.query(objects.Node.model).count(), 0)
self.assertEqual(self.db.query(objects.Cluster.model).count(), 0)
def test_all_controllers(self):
self.assertEqual(len(objects.Cluster.get_nodes_by_role(
self.env.clusters[0], 'controller')), 2)
self.cluster, 'controller')), 2)
def test_put_delete_template_after_deployment(self):
allowed = [consts.CLUSTER_STATUSES.new,
@ -1207,19 +1198,19 @@ class TestClusterObject(BaseTestCase):
consts.CLUSTER_STATUSES.error,
consts.CLUSTER_STATUSES.partially_deployed]
for status in consts.CLUSTER_STATUSES:
self.env.clusters[0].status = status
self.cluster.status = status
self.db.flush()
self.assertEqual(
objects.Cluster.is_network_modification_locked(
self.env.clusters[0]),
self.cluster),
status not in allowed
)
def test_get_controller_group_id(self):
controllers = objects.Cluster.get_nodes_by_role(
self.env.clusters[0], 'controller')
self.cluster, 'controller')
group_id = objects.Cluster.get_controllers_group_id(
self.env.clusters[0])
self.cluster)
self.assertEqual(controllers[0].group_id, group_id)
def test_get_node_group(self):
@ -1284,7 +1275,7 @@ class TestClusterObject(BaseTestCase):
for inf in node.nic_interfaces:
interfaces.append(inf)
nic_interfaces = objects.Cluster.get_nic_interfaces_for_all_nodes(
self.env.clusters[0])
self.cluster)
self.assertEqual(len(nic_interfaces), len(interfaces))
def test_get_bond_interfaces_for_all_nodes(self):
@ -1294,14 +1285,13 @@ class TestClusterObject(BaseTestCase):
slaves=node.nic_interfaces))
self.db.flush()
bond_interfaces = objects.Cluster.get_bond_interfaces_for_all_nodes(
self.env.clusters[0])
self.cluster)
self.assertEqual(len(bond_interfaces), 1)
def test_get_network_roles(self):
cluster = self.env.clusters[0]
self.assertItemsEqual(
objects.Cluster.get_network_roles(cluster),
cluster.release.network_roles_metadata)
objects.Cluster.get_network_roles(self.cluster),
self.cluster.release.network_roles_metadata)
def test_get_deployment_tasks(self):
deployment_tasks = self.env.get_default_plugin_deployment_tasks()
@ -1445,17 +1435,16 @@ class TestClusterObject(BaseTestCase):
plugin_volumes_metadata['volumes'])
volumes_metadata = objects.Cluster.get_volumes_metadata(
self.env.clusters[0])
self.cluster)
self.assertDictEqual(
volumes_metadata, expected_volumes_metadata)
def test_cluster_is_component_enabled(self):
cluster = self.env.clusters[0]
self.assertFalse(objects.Cluster.is_component_enabled(cluster,
self.assertFalse(objects.Cluster.is_component_enabled(self.cluster,
'ironic'))
self.env._set_additional_component(cluster, 'ironic', True)
self.assertTrue(objects.Cluster.is_component_enabled(cluster,
self.env._set_additional_component(self.cluster, 'ironic', True)
self.assertTrue(objects.Cluster.is_component_enabled(self.cluster,
'ironic'))
def test_get_cluster_attributes_by_components(self):
@ -1621,7 +1610,7 @@ class TestClusterObjectVirtRoles(BaseTestCase):
def setUp(self):
super(TestClusterObjectVirtRoles, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'roles': ['virt']},
{'roles': ['virt']},
@ -1640,14 +1629,14 @@ class TestClusterObjectVirtRoles(BaseTestCase):
]
def test_set_vms_created_state(self):
objects.Cluster.set_vms_created_state(self.env.clusters[0])
objects.Cluster.set_vms_created_state(self.cluster)
for node in self.env.nodes:
for conf in node.vms_conf:
self.assertTrue(conf['created'])
def test_reset_vms_created_state(self):
objects.Cluster.set_vms_created_state(self.env.clusters[0])
objects.Cluster.set_vms_created_state(self.cluster)
objects.Node.reset_vms_created_state(self.env.nodes[0])
@ -1663,7 +1652,7 @@ class TestClusterObjectGetRoles(BaseTestCase):
def setUp(self):
super(TestClusterObjectGetRoles, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={
'roles_metadata': {
'role_a': {
@ -1672,7 +1661,6 @@ class TestClusterObjectGetRoles(BaseTestCase):
'name': 'Role B', 'description': 'Role B is ...', },
}
})
self.cluster = self.env.clusters[0]
def create_plugin(self, roles_metadata):
plugin = objects.Plugin.create(self.env.get_default_plugin_metadata(
@ -1756,7 +1744,8 @@ class TestClusterObjectGetRoles(BaseTestCase):
class TestClusterObjectGetNetworkManager(BaseTestCase):
def setUp(self):
super(TestClusterObjectGetNetworkManager, self).setUp()
self.env.create(cluster_kwargs={'net_provider': 'neutron'})
self.cluster = self.env.create(
cluster_kwargs={'net_provider': 'neutron'})
def test_get_default(self):
nm = objects.Cluster.get_network_manager()
@ -1764,19 +1753,17 @@ class TestClusterObjectGetNetworkManager(BaseTestCase):
def check_neutron_network_manager(
self, net_provider, version, expected_manager):
cluster = self.env.clusters[0]
cluster.net_provider = net_provider
cluster.release.version = version
nm = objects.Cluster.get_network_manager(cluster)
self.cluster.net_provider = net_provider
self.cluster.release.version = version
nm = objects.Cluster.get_network_manager(self.cluster)
self.assertIs(expected_manager, nm)
def test_raise_if_unknown(self):
cluster = self.env.clusters[0]
cluster.net_provider = "invalid_data"
self.cluster.net_provider = "invalid_data"
self.assertRaisesWithMessage(
Exception,
'The network provider "invalid_data" is not supported.',
objects.Cluster.get_network_manager, cluster
objects.Cluster.get_network_manager, self.cluster
)
def test_neutron_network_managers_by_version(self):
@ -1803,8 +1790,8 @@ class TestClusterObjectGetNetworkManager(BaseTestCase):
)
def test_get_neutron_80(self):
self.env.clusters[0].release.version = '2014.2.2-8.0'
nm = objects.Cluster.get_network_manager(self.env.clusters[0])
self.cluster.release.version = '2014.2.2-8.0'
nm = objects.Cluster.get_network_manager(self.cluster)
self.assertEqual(nm, neutron.NeutronManager80)
@ -1934,14 +1921,13 @@ class TestOpenstackConfig(BaseTestCase):
def setUp(self):
super(TestOpenstackConfig, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'role': 'controller', 'status': 'ready'},
{'role': 'compute', 'status': 'ready'},
{'role': 'cinder', 'status': 'ready'},
])
self.cluster = self.env.clusters[0]
self.nodes = self.env.nodes
def test_create(self):
@ -2007,14 +1993,13 @@ class TestOpenstackConfigCollection(BaseTestCase):
def setUp(self):
super(TestOpenstackConfigCollection, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'role': 'controller', 'status': 'ready'},
{'role': 'compute', 'status': 'ready'},
{'role': 'cinder', 'status': 'ready'},
])
self.cluster = self.env.clusters[0]
self.nodes = self.env.nodes
def test_create(self):
@ -2093,10 +2078,9 @@ class TestNICObject(BaseTestCase):
def setUp(self):
super(TestNICObject, self).setUp()
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={'api': False},
nodes_kwargs=[{'role': 'controller'}])
self.cluster = self.env.clusters[0]
def test_replace_assigned_networks(self):
node = self.env.nodes[0]
@ -2133,10 +2117,9 @@ class TestIPAddrObject(BaseTestCase):
def setUp(self):
super(TestIPAddrObject, self).setUp()
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={'api': False},
nodes_kwargs=[{'role': 'controller'}])
self.cluster = self.env.clusters[0]
def test_get_ips_except_admin(self):
node = self.env.nodes[0]

3
nailgun/nailgun/test/unit/test_plugin_adapters.py
View File

@ -63,14 +63,13 @@ class TestPluginBase(base.BaseTestCase):
}
)
self.plugin = Plugin.create(self.plugin_metadata)
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={'mode': consts.CLUSTER_MODES.multinode},
release_kwargs={
'version': '2015.1-8.0',
'operating_system': 'Ubuntu',
'modes': [consts.CLUSTER_MODES.multinode,
consts.CLUSTER_MODES.ha_compact]})
self.cluster = self.env.clusters[0]
self.plugin_adapter = adapters.wrap_plugin(self.plugin)
self.env_config = self.env.get_default_plugin_env_config()
self.get_config = lambda *args: mock.mock_open(

15
nailgun/nailgun/test/unit/test_primary_roles_assignment.py
View File

@ -38,7 +38,7 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
pass
def test_primary_controllers_assigned_for_pendings_roles(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'mode': consts.CLUSTER_MODES.ha_compact},
release_kwargs={'version': '2014.2-6.0',
'operating_system': 'Ubuntu'},
@ -49,7 +49,6 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
{'pending_roles': [self.role_name],
'status': consts.NODE_STATUSES.discover,
'pending_addition': True}])
cluster = self.env.clusters[0]
objects.Cluster.set_primary_roles(cluster, cluster.nodes)
nodes = sorted(cluster.nodes, key=lambda node: node.id)
# with lowest uid is assigned as primary
@ -59,7 +58,7 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
objects.Node.all_roles(nodes[1]), [self.role_name])
def test_primary_controller_assigned_for_ready_node(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'mode': consts.CLUSTER_MODES.ha_compact},
release_kwargs={'version': '2014.2-6.0',
'operating_system': 'Ubuntu'},
@ -70,7 +69,6 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
{'roles': [self.role_name],
'status': consts.NODE_STATUSES.ready,
'pending_addition': True}])
cluster = self.env.clusters[0]
objects.Cluster.set_primary_roles(cluster, cluster.nodes)
# primary assigned to node with ready status
nodes = sorted(cluster.nodes, key=lambda node: node.id)
@ -84,7 +82,7 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
def test_primary_assignment_multinode(self):
"""Primary should not be assigned in multinode env."""
self.env.create(
cluster = self.env.create(
cluster_kwargs={'mode': consts.CLUSTER_MODES.multinode},
release_kwargs={'version': '2014.2-6.0',
'operating_system': 'Ubuntu',
@ -97,7 +95,6 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
{'roles': [self.role_name],
'status': consts.NODE_STATUSES.ready,
'pending_addition': True}])
cluster = self.env.clusters[0]
objects.Cluster.set_primary_roles(cluster, cluster.nodes)
self.assertEqual(
objects.Node.all_roles(cluster.nodes[0]), [self.role_name])
@ -105,7 +102,7 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
objects.Node.all_roles(cluster.nodes[1]), [self.role_name])
def test_primary_not_assigned_to_pending_deletion(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'mode': consts.CLUSTER_MODES.ha_compact},
release_kwargs={'version': '2014.2-6.0',
'operating_system': 'Ubuntu'},
@ -113,14 +110,13 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
{'roles': [self.role_name],
'status': consts.NODE_STATUSES.ready,
'pending_deletion': True}])
cluster = self.env.clusters[0]
objects.Cluster.set_primary_roles(cluster, cluster.nodes)
self.assertEqual(
objects.Node.all_roles(cluster.nodes[0]), [self.role_name])
@contextmanager
def assert_node_reassigned(self):
self.env.create(
cluster = self.env.create(
cluster_kwargs={'mode': consts.CLUSTER_MODES.ha_compact},
release_kwargs={'version': '2014.2-6.0',
'operating_system': 'Ubuntu'},
@ -131,7 +127,6 @@ class BasePrimaryRolesAssignmentTestCase(base.BaseTestCase):
{'roles': [self.role_name],
'status': consts.NODE_STATUSES.ready,
'pending_addition': True}])
cluster = self.env.clusters[0]
objects.Cluster.set_primary_roles(cluster, cluster.nodes)
nodes = sorted(cluster.nodes, key=lambda node: node.id)
self.assertEqual(

3
nailgun/nailgun/test/unit/test_receiver.py
View File

@ -30,12 +30,11 @@ class TestNailgunReceiver(base.BaseTestCase):
def setUp(self):
super(TestNailgunReceiver, self).setUp()
self.env.create(
self.cluster = self.env.create(
status=consts.CLUSTER_STATUSES.operational,
nodes_kwargs=[
{'roles': ['controller'],
'status': consts.NODE_STATUSES.ready}])
self.cluster = self.env.clusters[0]
for i in range(2):
meta = self.env.get_default_plugin_metadata(

18
nailgun/nailgun/test/unit/test_redeployment_scenarios.py
View File

@ -32,45 +32,42 @@ class TestClusterRedeploymentScenario(base.BaseTestCase):
nodes_kwargs=nodes_kwargs)
def test_cluster_deployed_with_computes(self):
self.create_env(
cluster = self.create_env(
nodes_kwargs=[
{'pending_roles': ['controller'],
'status': 'discover',
'pending_addition': True},
{'roles': ['compute'],
'status': 'ready'}])
cluster = self.env.clusters[0]
nodes = helpers.TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(cluster.nodes, nodes)
def test_cluster_deployed_with_cinder(self):
self.create_env(
cluster = self.create_env(
nodes_kwargs=[
{'pending_roles': ['controller'],
'status': 'discover',
'pending_addition': True},
{'roles': ['cinder'],
'status': 'ready'}])
cluster = self.env.clusters[0]
nodes = helpers.TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(cluster.nodes, nodes)
def test_ceph_osd_is_not_affected(self):
self.create_env(
cluster = self.create_env(
nodes_kwargs=[
{'pending_roles': ['controller'],
'status': 'discover',
'pending_addition': True},
{'roles': ['ceph-osd'],
'status': 'ready'}])
cluster = self.env.clusters[0]
nodes = helpers.TaskHelper.nodes_to_deploy(cluster)
self.assertNotEqual(cluster.nodes, nodes)
self.assertEqual(len(nodes), 1)
self.assertEqual(nodes[0].pending_roles, ['controller'])
def test_cinder_is_not_affected_when_add_compute(self):
self.create_env(
cluster = self.create_env(
nodes_kwargs=[
{'roles': ['controller'],
'status': 'ready'},
@ -79,27 +76,25 @@ class TestClusterRedeploymentScenario(base.BaseTestCase):
'pending_addition': True},
{'roles': ['cinder'],
'status': 'ready'}])
cluster = self.env.clusters[0]
nodes = helpers.TaskHelper.nodes_to_deploy(cluster)
self.assertNotEqual(cluster.nodes, nodes)
self.assertEqual(len(nodes), 1)
self.assertEqual(nodes[0].pending_roles, ['compute'])
def test_controllers_redeployed_if_ceph_added(self):
self.create_env(
cluster = self.create_env(
nodes_kwargs=[
{'roles': ['controller'],
'status': 'ready'},
{'pending_roles': ['ceph-osd'],
'status': 'discover',
'pending_addition': True}])
cluster = self.env.clusters[0]
nodes = helpers.TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(nodes), 2)
self.assertEqual(sorted(cluster.nodes), sorted(nodes))
def test_controllers_not_redeployed_if_ceph_previously_in_cluster(self):
self.create_env(
cluster = self.create_env(
nodes_kwargs=[
{'roles': ['controller'],
'status': 'ready'},
@ -108,7 +103,6 @@ class TestClusterRedeploymentScenario(base.BaseTestCase):
{'pending_roles': ['ceph-osd'],
'status': 'discover',
'pending_addition': True}])
cluster = self.env.clusters[0]
nodes = helpers.TaskHelper.nodes_to_deploy(cluster)
self.assertEqual(len(nodes), 1)
self.assertEqual(nodes[0].pending_roles, ['ceph-osd'])

20
nailgun/nailgun/test/unit/test_task.py
View File

@ -32,7 +32,7 @@ class TestClusterDeletionTask(BaseTestCase):
def create_cluster_and_execute_deletion_task(
self, attributes=None, os=consts.RELEASE_OS.centos):
self.env.create(
cluster = self.env.create(
cluster_kwargs={
'editable_attributes': attributes,
},
@ -42,7 +42,7 @@ class TestClusterDeletionTask(BaseTestCase):
},
)
self.fake_task = Task(name=consts.TASK_NAMES.cluster_deletion,
cluster=self.env.clusters[0])
cluster=cluster)
task.ClusterDeletionTask.execute(self.fake_task)
@mock.patch('nailgun.task.task.DeletionTask', autospec=True)
@ -133,7 +133,7 @@ class TestHelperUpdateClusterStatus(BaseTestCase):
def setUp(self):
super(TestHelperUpdateClusterStatus, self).setUp()
self.env.create(
self.cluster = self.env.create(
nodes_kwargs=[
{'roles': ['controller']},
{'roles': ['compute', 'virt']},
@ -148,10 +148,6 @@ class TestHelperUpdateClusterStatus(BaseTestCase):
for node in nodes:
self.assertEqual(node.status, 'discover')
@property
def cluster(self):
return self.env.clusters[0]
def test_update_nodes_to_error_if_deployment_task_failed(self):
self.cluster.nodes[0].status = 'deploying'
self.cluster.nodes[0].progress = 12
@ -288,7 +284,7 @@ class TestCheckBeforeDeploymentTask(BaseTestCase):
def setUp(self):
super(TestCheckBeforeDeploymentTask, self).setUp()
self.env.create(
self.cluster = self.env.create(
release_kwargs={'version': '1111-8.0'},
cluster_kwargs={
'net_provider': 'neutron',
@ -305,8 +301,7 @@ class TestCheckBeforeDeploymentTask(BaseTestCase):
self.env.create_node()
self.node = self.env.nodes[0]
self.cluster = self.env.clusters[0]
self.task = Task(cluster_id=self.env.clusters[0].id)
self.task = Task(cluster_id=self.cluster.id)
self.env.db.add(self.task)
self.env.db.commit()
@ -530,7 +525,7 @@ class TestCheckBeforeDeploymentTask(BaseTestCase):
)
def test_check_public_networks(self):
cluster = self.env.clusters[0]
cluster = self.cluster
self.env.create_nodes(
2, api=True, roles=['controller'], cluster_id=cluster.id)
self.env.create_nodes(
@ -674,8 +669,7 @@ class TestCheckBeforeDeploymentTask(BaseTestCase):
class TestDeployTask(BaseTestCase):
def create_deploy_tasks(self):
self.env.create()
cluster = self.env.clusters[0]
cluster = self.env.create()
deploy_task = Task(name=consts.TASK_NAMES.deploy,
cluster_id=cluster.id,

3
nailgun/nailgun/test/unit/test_task_handler.py
View File

@ -24,12 +24,11 @@ class TestTaskHandlers(BaseTestCase):
def setUp(self):
super(TestTaskHandlers, self).setUp()
self.env.create(
self.cluster_db = self.env.create(
nodes_kwargs=[
{"roles": ["controller"]}
]
)
self.cluster_db = self.env.clusters[0]
def test_task_deletion(self):
task = Task(

6
nailgun/nailgun/test/unit/test_task_helpers.py
View File

@ -208,12 +208,11 @@ class TestTaskHelpers(BaseTestCase):
self.assertDictEqual(expected, actual)
def test_prepare_action_log_kwargs_with_web_ctx(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['compute'], 'provisioning': True},
]
)
cluster = self.env.clusters[0]
task = Task(name='provision', cluster_id=cluster.id)
self.db.add(task)
self.db.flush()
@ -231,13 +230,12 @@ class TestTaskHelpers(BaseTestCase):
self.assertIsNone(kwargs['actor_id'])
def test_prepare_action_log_kwargs_without_web_ctx(self):
self.env.create(
cluster = self.env.create(
nodes_kwargs=[
{'roles': ['compute'], 'pending_addition': True},
{'roles': ['controller'], 'pending_addition': True},
]
)
cluster = self.env.clusters[0]
deployment_task = Task(name='deployment', cluster_id=cluster.id)
self.db.add(deployment_task)
self.db.flush()

3
nailgun/nailgun/test/unit/test_task_managers.py
View File

@ -27,8 +27,7 @@ class TestDeploymentCheckMixin(BaseTestCase):
def setUp(self):
super(TestDeploymentCheckMixin, self).setUp()
self.env.create()
self.cluster = self.env.clusters[0]
self.cluster = self.env.create()
def test_fails_if_there_is_task(self):
for task_name in DeploymentCheckMixin.deployment_tasks:

3
nailgun/nailgun/test/unit/test_transaction_handler.py
View File

@ -25,12 +25,11 @@ class TestTransactionHandlers(BaseTestCase):
def setUp(self):
super(TestTransactionHandlers, self).setUp()
self.env.create(
self.cluster_db = self.env.create(
nodes_kwargs=[
{"roles": ["controller"]}
]
)
self.cluster_db = self.env.clusters[0]
def test_transaction_deletion(self):
task = Task(

3
nailgun/nailgun/test/unit/test_vmware_attributes_validator.py
View File

@ -26,7 +26,7 @@ from nailgun.test.base import BaseTestCase
class TestAttributesValidator(BaseTestCase):
def setUp(self):
super(TestAttributesValidator, self).setUp()
self.env.create(
self.cluster = self.env.create(
cluster_kwargs={
"api": False,
"vmware_attributes": {
@ -38,7 +38,6 @@ class TestAttributesValidator(BaseTestCase):
"status": consts.NODE_STATUSES.ready
}]
)
self.cluster = self.env.clusters[0]
self.ready_compute_node = self.env.create_node(
hostname="node-1",
name="Node 1",