« back to all changes in this revision
Viewing changes to quantum/plugins/cisco/tests/unit/test_ucs_plugin.py
- browse files at revision 72
- compare with another revision
- download diff
- download tarball
- view history from revision 72
- Committer: Dan Wendlandt
- Date: 2011-09-09 23:38:20 UTC
- mfrom: (21.27.59 unit_tests)
- Revision ID: dan@nicira.com-20110909233820-07kz5nh73s1jv557
merge tyler's unit tests for cisco plugin changes lp845140
- files modified:
- quantum/plugins/cisco/common/cisco_constants.py
added
removed
quantum/plugins/cisco/tests/unit/test_ucs_plugin.py
14
14
# under the License.
15
15
#
16
16
# @author: Shubhangi Satras, Cisco Systems, Inc.
17
# Shweta Padubidri, Cisco Systems, Inc.
17
18
#
18
19
import unittest
19
20
import logging as LOG
21
22
from quantum.plugins.cisco.common import cisco_constants as const
22
23
from quantum.plugins.cisco.ucs import cisco_ucs_plugin
23
24
from quantum.plugins.cisco.ucs import cisco_ucs_configuration as conf
25
from quantum.plugins.cisco.common import cisco_credentials as cred
26
27
from quantum.plugins.cisco.db import api as db
28
from quantum.plugins.cisco.db import l2network_db as cdb
29
from quantum.plugins.cisco.common import cisco_exceptions as c_exc
30
31
from quantum.plugins.cisco.ucs import cisco_ucs_inventory as ucsinv
24
32
25
33
LOG.basicConfig(level=LOG.WARN)
26
LOG.getLogger("cisco_plugin")
34
LOG.getLogger("cisco_ucs_plugin")
27
35
28
36
29
37
class UCSVICTestPlugin(unittest.TestCase):
30
38
31
39
def setUp(self):
32
"""
33
Set up function.
34
"""
35
40
36
41
self.tenant_id = "test_tenant_cisco12"
37
42
self.net_name = "test_network_cisco12"
38
43
self.net_id = 000011
39
self.vlan_name = "q-" + str(self.net_id) + "vlan"
40
self.vlan_id = 266
44
self.vlan_name = conf.DEFAULT_VLAN_NAME
45
self.vlan_id = conf.DEFAULT_VLAN_ID
41
46
self.port_id = "4"
47
cdb.initialize()
48
cred.Store.initialize()
42
49
self._cisco_ucs_plugin = cisco_ucs_plugin.UCSVICPlugin()
50
self.device_ip = conf.UCSM_IP_ADDRESS
51
self._ucs_inventory = ucsinv.UCSInventory()
52
self.chassis_id = '1'
53
self.blade_id = '5'
54
self.blade_intf_distinguished_name = 'sys/chassis-1/blade-5/'\
55
'adaptor-1/host-eth-6'
43
56
44
57
def test_create_network(self):
45
58
"""
46
59
Tests creation of new Virtual Network.
47
60
"""
48
61
LOG.debug("UCSVICTestPlugin:_test_create_network() called\n")
62
new_network = db.network_create(self.tenant_id, self.net_name)
63
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
64
new_network[const.UUID])
49
65
new_net_dict = self._cisco_ucs_plugin.create_network(
50
self.tenant_id, self.net_name, self.net_id,
51
self.vlan_name, self.vlan_id)
52
self.assertEqual(new_net_dict[const.NET_ID], self.net_id)
53
self.assertEqual(new_net_dict[const.NET_NAME], self.net_name)
54
self.assertEqual(new_net_dict[const.NET_VLAN_NAME], self.vlan_name)
55
self.assertEqual(new_net_dict[const.NET_VLAN_ID], self.vlan_id)
56
self.tearDownNetwork(self.tenant_id, self.net_id)
66
self.tenant_id, new_network[const.NETWORKNAME],
67
new_network[const.UUID], self.vlan_name, self.vlan_id,
68
device_ip=self.device_ip)
69
self.assertEqual(new_net_dict[const.NET_ID], new_network[const.UUID])
70
self.assertEqual(new_net_dict[const.NET_NAME],
71
new_network[const.NETWORKNAME])
72
self.tearDownNetwork(self.tenant_id, new_network[const.UUID])
57
73
58
74
def test_delete_network(self):
59
75
"""
61
77
belonging to the specified tenant.
62
78
"""
63
79
LOG.debug("UCSVICTestPlugin:test_delete_network() called\n")
64
self._cisco_ucs_plugin.create_network(
65
self.tenant_id, self.net_name, self.net_id,
66
self.vlan_name, self.vlan_id)
80
new_network = db.network_create(self.tenant_id, self.net_name)
81
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
82
new_network[const.UUID])
83
new_net_dict = self._cisco_ucs_plugin.create_network(
84
self.tenant_id, new_network[const.NETWORKNAME],
85
new_network[const.UUID], self.vlan_name, self.vlan_id,
86
device_ip=self.device_ip)
67
87
new_net_dict = self._cisco_ucs_plugin.delete_network(
68
self.tenant_id, self.net_id)
69
self.assertEqual(new_net_dict[const.NET_ID], self.net_id)
88
self.tenant_id, new_network[const.UUID], device_ip=self.device_ip)
89
self.assertEqual(new_net_dict[const.NET_ID], new_network[const.UUID])
70
90
71
91
def test_get_network_details(self):
72
92
"""
74
94
spec
75
95
"""
76
96
LOG.debug("UCSVICTestPlugin:test_get_network_details() called\n")
77
self._cisco_ucs_plugin.create_network(
78
self.tenant_id, self.net_name, self.net_id,
79
self.vlan_name, self.vlan_id)
97
new_network = db.network_create(self.tenant_id, self.net_name)
98
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
99
new_network[const.UUID])
100
new_net_dict = self._cisco_ucs_plugin.create_network(
101
self.tenant_id, new_network[const.NETWORKNAME],
102
new_network[const.UUID], self.vlan_name, self.vlan_id,
103
device_ip=self.device_ip)
80
104
new_net_dict = self._cisco_ucs_plugin.get_network_details(
81
self.tenant_id, self.net_id)
82
self.assertEqual(new_net_dict[const.NET_ID], self.net_id)
83
self.assertEqual(new_net_dict[const.NET_VLAN_NAME], self.vlan_name)
84
self.assertEqual(new_net_dict[const.NET_VLAN_ID], self.vlan_id)
85
self.tearDownNetwork(self.tenant_id, self.net_id)
105
self.tenant_id, new_network[const.UUID],
106
device_ip=self.device_ip)
107
self.assertEqual(new_net_dict[const.NET_ID], new_network[const.UUID])
108
self.assertEqual(new_net_dict[const.NET_NAME],
109
new_network[const.NETWORKNAME])
110
self.tearDownNetwork(self.tenant_id, new_network[const.UUID])
86
111
87
112
def test_get_all_networks(self):
88
113
"""
91
116
the specified tenant.
92
117
"""
93
118
LOG.debug("UCSVICTestPlugin:test_get_all_networks() called\n")
119
new_network1 = db.network_create(self.tenant_id, self.net_name)
120
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
121
new_network1[const.UUID])
94
122
new_net_dict1 = self._cisco_ucs_plugin.create_network(
95
self.tenant_id, self.net_name, self.net_id,
96
self.vlan_name, self.vlan_id)
123
self.tenant_id, new_network1[const.NETWORKNAME],
124
new_network1[const.UUID], self.vlan_name, self.vlan_id,
125
device_ip=self.device_ip)
126
new_network2 = db.network_create(self.tenant_id, "test_network2")
127
cdb.add_vlan_binding("6", "q-000006vlan", new_network2[const.UUID])
97
128
new_net_dict2 = self._cisco_ucs_plugin.create_network(
98
self.tenant_id, "test_network2",
99
000006, "q-000006vlan", "6")
100
net_list = self._cisco_ucs_plugin.get_all_networks(self.tenant_id)
129
self.tenant_id, new_network2[const.NETWORKNAME],
130
new_network2[const.UUID], "q-000006vlan", "6",
131
device_ip=self.device_ip)
132
133
net_list = self._cisco_ucs_plugin.get_all_networks(
134
self.tenant_id, device_ip=self.device_ip)
101
135
net_id_list = [new_net_dict1, new_net_dict2]
136
102
137
self.assertTrue(net_list[0] in net_id_list)
103
138
self.assertTrue(net_list[1] in net_id_list)
104
self.tearDownNetwork(self.tenant_id, new_net_dict1[const.NET_ID])
105
self.tearDownNetwork(self.tenant_id, new_net_dict2[const.NET_ID])
139
self.tearDownNetwork(self.tenant_id, new_network1[const.UUID])
140
self.tearDownNetwork(self.tenant_id, new_network2[const.UUID])
106
141
107
142
def test_get_all_ports(self):
108
143
"""
110
145
specified Virtual Network.
111
146
"""
112
147
LOG.debug("UCSVICPlugin:get_all_ports() called\n")
148
new_network = db.network_create(self.tenant_id, self.net_name)
149
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
150
new_network[const.UUID])
113
151
new_net_dict = self._cisco_ucs_plugin.create_network(
114
self.tenant_id, self.net_name, self.net_id,
115
self.vlan_name, self.vlan_id)
152
self.tenant_id, new_network[const.NETWORKNAME],
153
new_network[const.UUID], self.vlan_name, self.vlan_id,
154
device_ip=self.device_ip)
155
new_port1 = db.port_create(new_network[const.UUID], const.PORT_UP)
116
156
port_dict1 = self._cisco_ucs_plugin.create_port(
117
self.tenant_id, self.net_id, const.PORT_UP,
118
self.port_id)
157
self.tenant_id, self.net_id, const.PORT_UP,
158
new_port1[const.UUID], device_ip=self.device_ip,
159
ucs_inventory=self._ucs_inventory,
160
least_rsvd_blade_dict=self._ucs_inventory.\
161
_get_least_reserved_blade())
162
new_port2 = db.port_create(new_network[const.UUID], const.PORT_UP)
119
163
port_dict2 = self._cisco_ucs_plugin.create_port(
120
self.tenant_id, self.net_id,
121
const.PORT_UP, "10")
164
self.tenant_id, self.net_id, const.PORT_UP,
165
new_port2[const.UUID], device_ip=self.device_ip,
166
ucs_inventory=self._ucs_inventory,
167
least_rsvd_blade_dict=self._ucs_inventory.\
168
_get_least_reserved_blade())
122
169
ports_on_net = self._cisco_ucs_plugin.get_all_ports(
123
self.tenant_id, self.net_id)
170
self.tenant_id, new_net_dict[const.NET_ID],
171
device_ip=self.device_ip,
172
ucs_inventory=self._ucs_inventory,
173
least_rsvd_blade_dict=self._ucs_inventory.\
174
_get_least_reserved_blade())
124
175
port_list = [port_dict1, port_dict2]
125
self.assertTrue(port_list[0] in ports_on_net)
126
self.assertTrue(port_list[1] in ports_on_net)
127
self._cisco_ucs_plugin.delete_port(self.tenant_id, self.net_id,
128
self.port_id)
129
self.tearDownNetworkPort(self.tenant_id, new_net_dict[const.NET_ID],
130
port_dict2[const.PORT_ID])
131
132
def _test_rename_network(self, new_name):
133
"""
134
Tests whether symbolic name is updated for the particular
135
Virtual Network.
136
"""
137
LOG.debug("UCSVICTestPlugin:_test_rename_network() called\n")
138
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
139
self.net_id, self.vlan_name,
140
self.vlan_id)
141
new_net_dict = self._cisco_ucs_plugin.rename_network(
142
self.tenant_id, self.net_id, new_name)
143
self.assertEqual(new_net_dict[const.NET_NAME], new_name)
144
self.tearDownNetwork(self.tenant_id, self.net_id)
145
146
def test_rename_network(self):
147
"""
148
Tests rename network.
149
"""
150
self._test_rename_network("new_test_network1")
151
152
def _test_create_port(self, port_state):
176
self.assertTrue(str(ports_on_net[1]) == str(port_list[1]) or
177
str(ports_on_net[1]) == str(port_list[0]))
178
self.assertTrue(str(ports_on_net[0]) == str(port_list[1]) or
179
str(ports_on_net[0]) == str(port_list[0]))
180
181
self._cisco_ucs_plugin.delete_port(
182
self.tenant_id, new_net_dict[const.NET_ID],
183
port_dict1[const.PORTID], device_ip=self.device_ip,
184
ucs_inventory=self._ucs_inventory,
185
chassis_id=self.chassis_id, blade_id=self.blade_id,
186
blade_intf_distinguished_name=self.\
187
blade_intf_distinguished_name,
188
least_rsvd_blade_dict=self._ucs_inventory.\
189
_get_least_reserved_blade())
190
self.tearDownNetworkPort(
191
self.tenant_id, new_net_dict[const.NET_ID],
192
port_dict2[const.PORTID])
193
194
def test_create_port(self):
153
195
"""
154
196
Tests creation of a port on the specified Virtual Network.
155
197
"""
156
198
LOG.debug("UCSVICTestPlugin:_test_create_port() called\n")
157
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
158
self.net_id, self.vlan_name,
159
self.vlan_id)
160
new_port_dict = self._cisco_ucs_plugin.create_port(
161
self.tenant_id, self.net_id, port_state, self.port_id)
162
self.assertEqual(new_port_dict[const.PORT_ID], self.port_id)
163
self.assertEqual(new_port_dict[const.PORT_STATE], port_state)
164
self.assertEqual(new_port_dict[const.ATTACHMENT], None)
165
profile_name = self._cisco_ucs_plugin._get_profile_name(self.port_id)
166
new_port_profile = new_port_dict[const.PORT_PROFILE]
167
self.assertEqual(new_port_profile[const.PROFILE_NAME], profile_name)
168
self.assertEqual(new_port_profile[const.PROFILE_VLAN_NAME],
169
conf.DEFAULT_VLAN_NAME)
170
self.assertEqual(new_port_profile[const.PROFILE_VLAN_ID],
171
conf.DEFAULT_VLAN_ID)
172
self.tearDownNetworkPort(self.tenant_id, self.net_id, self.port_id)
173
174
def test_create_port(self):
175
"""
176
Tests create port.
177
"""
178
self._test_create_port(const.PORT_UP)
179
180
def _test_delete_port(self, port_state):
199
200
new_network = db.network_create(self.tenant_id, self.net_name)
201
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
202
new_network[const.UUID])
203
new_net_dict = self._cisco_ucs_plugin.create_network(
204
self.tenant_id, new_network[const.NETWORKNAME],
205
new_network[const.UUID], self.vlan_name, self.vlan_id,
206
device_ip=self.device_ip)
207
new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
208
port_dict = self._cisco_ucs_plugin.create_port(
209
self.tenant_id, self.net_id, const.PORT_UP,
210
new_port[const.UUID], device_ip=self.device_ip,
211
ucs_inventory=self._ucs_inventory,
212
least_rsvd_blade_dict=self._ucs_inventory.\
213
_get_least_reserved_blade())
214
self.assertEqual(port_dict[const.PORTID], new_port[const.UUID])
215
profile_name = self._cisco_ucs_plugin.\
216
_get_profile_name(port_dict[const.PORTID])
217
self.assertTrue(profile_name != None)
218
self.tearDownNetworkPort(
219
self.tenant_id, new_net_dict[const.NET_ID],
220
port_dict[const.PORTID])
221
222
def test_delete_port(self):
181
223
"""
182
224
Tests Deletion of a port on a specified Virtual Network,
183
225
if the port contains a remote interface attachment,
185
227
then the port can be deleted.
186
228
"""
187
229
LOG.debug("UCSVICTestPlugin:_test_delete_port() called\n")
188
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
189
self.net_id, self.vlan_name,
190
self.vlan_id)
191
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
192
port_state, self.port_id)
193
self._cisco_ucs_plugin.delete_port(self.tenant_id, self.net_id,
194
self.port_id)
195
net = self._cisco_ucs_plugin._get_network(self.tenant_id, self.net_id)
196
self.assertEqual(net[const.NET_PORTS], {})
197
self.tearDownNetwork(self.tenant_id, self.net_id)
198
199
def test_delete_port(self):
200
"""
201
Tests delete port.
202
"""
203
self._test_delete_port(const.PORT_UP)
204
205
def _test_update_port(self, port_state):
206
"""
207
Tests Updation of the state of a port on the specified Virtual Network.
208
"""
209
LOG.debug("UCSVICTestPlugin:_test_update_port() called\n")
210
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
211
self.net_id, self.vlan_name,
212
self.vlan_id)
213
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
214
port_state, self.port_id)
215
port = self._cisco_ucs_plugin.update_port(
216
self.tenant_id, self.net_id,
217
self.port_id, port_state)
218
self.assertEqual(port[const.PORT_STATE], port_state)
219
self.tearDownNetworkPort(self.tenant_id, self.net_id, self.port_id)
220
221
def test_update_port_state_up(self):
222
"""
223
Tests update port state up
224
"""
225
self._test_update_port(const.PORT_UP)
226
227
def test_update_port_state_down(self):
228
"""
229
Tests update port state down
230
"""
231
self._test_update_port(const.PORT_DOWN)
232
233
def _test_get_port_details_state_up(self, port_state):
230
new_network = db.network_create(self.tenant_id, self.net_name)
231
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
232
new_network[const.UUID])
233
new_net_dict = self._cisco_ucs_plugin.create_network(
234
self.tenant_id, new_network[const.NETWORKNAME],
235
new_network[const.UUID], self.vlan_name, self.vlan_id,
236
device_ip=self.device_ip)
237
new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
238
port_dict = self._cisco_ucs_plugin.create_port(
239
self.tenant_id, self.net_id, const.PORT_UP,
240
new_port[const.UUID], device_ip=self.device_ip,
241
ucs_inventory=self._ucs_inventory,
242
least_rsvd_blade_dict=self._ucs_inventory.\
243
_get_least_reserved_blade())
244
port_bind = self._cisco_ucs_plugin.delete_port(
245
self.tenant_id, new_net_dict[const.NET_ID],
246
port_dict[const.PORTID], device_ip=self.device_ip,
247
ucs_inventory=self._ucs_inventory,
248
chassis_id=self.chassis_id, blade_id=self.blade_id,
249
blade_intf_distinguished_name=self.\
250
blade_intf_distinguished_name,
251
least_rsvd_blade_dict=self._ucs_inventory.\
252
_get_least_reserved_blade())
253
254
self.assertEqual(port_bind[const.PORTID], new_port[const.UUID])
255
self.tearDownNetwork(self.tenant_id, new_net_dict[const.NET_ID])
256
257
def _test_get_port_details(self, port_state):
234
258
"""
235
259
Tests whether user is able to retrieve a remote interface
236
260
that is attached to this particular port when port state is Up.
237
261
"""
238
LOG.debug("UCSVICTestPlugin:_test_get_port_details_state_up()" +
239
"called\n")
240
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
241
self.net_id, self.vlan_name,
242
self.vlan_id)
243
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
244
port_state, self.port_id)
245
port = self._cisco_ucs_plugin.get_port_details(
246
self.tenant_id, self.net_id, self.port_id)
247
self.assertEqual(port[const.PORT_ID], self.port_id)
248
self.assertEqual(port[const.PORT_STATE], port_state)
249
self.assertEqual(port[const.ATTACHMENT], None)
250
new_port_profile = port[const.PORT_PROFILE]
251
profile_name = self._cisco_ucs_plugin._get_profile_name(self.port_id)
252
self.assertEqual(new_port_profile[const.PROFILE_VLAN_NAME],
253
conf.DEFAULT_VLAN_NAME)
254
self.assertEqual(new_port_profile[const.PROFILE_VLAN_ID],
255
conf.DEFAULT_VLAN_ID)
256
self.assertEqual(new_port_profile[const.PROFILE_NAME], profile_name)
257
self.tearDownNetworkPort(self.tenant_id, self.net_id, self.port_id)
262
LOG.debug("UCSVICTestPlugin:_test_get_port_details() called\n")
263
new_network = db.network_create(self.tenant_id, self.net_name)
264
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
265
new_network[const.UUID])
266
new_net_dict = self._cisco_ucs_plugin.create_network(
267
self.tenant_id, new_network[const.NETWORKNAME],
268
new_network[const.UUID], self.vlan_name, self.vlan_id,
269
device_ip=self.device_ip)
270
new_port = db.port_create(new_network[const.UUID], port_state)
271
port_dict = self._cisco_ucs_plugin.create_port(
272
self.tenant_id, self.net_id, port_state,
273
new_port[const.UUID], device_ip=self.device_ip,
274
ucs_inventory=self._ucs_inventory,
275
least_rsvd_blade_dict=self._ucs_inventory.\
276
_get_least_reserved_blade())
258
277
259
def _test_show_port_state_down(self, port_state):
260
"""
261
Tests whether user is able to retrieve a remote interface
262
that is attached to this particular port when port state is down.
263
"""
264
LOG.debug("UCSVICTestPlugin:_test_show_port_state_down()" +
265
"called\n")
266
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
267
self.net_id, self.vlan_name,
268
self.vlan_id)
269
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
270
port_state, self.port_id)
271
port = self._cisco_ucs_plugin.get_port_details(self.tenant_id,
272
self.net_id,
273
self.port_id)
274
self.assertEqual(port[const.PORT_ID], self.port_id)
275
self.assertNotEqual(port[const.PORT_STATE], port_state)
276
self.assertEqual(port[const.ATTACHMENT], None)
277
new_port_profile = port[const.PORT_PROFILE]
278
profile_name = self._cisco_ucs_plugin._get_profile_name(self.port_id)
279
self.assertEqual(new_port_profile[const.PROFILE_VLAN_NAME],
280
conf.DEFAULT_VLAN_NAME)
281
self.assertEqual(new_port_profile[const.PROFILE_VLAN_ID],
282
conf.DEFAULT_VLAN_ID)
283
self.assertEqual(new_port_profile[const.PROFILE_NAME], profile_name)
284
self.tearDownNetworkPort(self.tenant_id, self.net_id, self.port_id)
278
port_detail = self._cisco_ucs_plugin.get_port_details(
279
self.tenant_id, new_net_dict[const.NET_ID],
280
port_dict[const.PORTID], device_ip=self.device_ip)
281
self.assertEqual(str(port_dict), str(port_detail))
282
self.tearDownNetworkPort(
283
self.tenant_id, new_net_dict[const.NET_ID],
284
port_dict[const.PORTID])
285
285
286
286
def test_get_port_details_state_up(self):
287
"""
288
Tests get port details state up
289
"""
290
self._test_get_port_details_state_up(const.PORT_UP)
287
self._test_get_port_details(const.PORT_UP)
291
288
292
289
def test_show_port_state_down(self):
293
"""
294
Tests show port state down
295
"""
296
self._test_show_port_state_down(const.PORT_DOWN)
290
self._test_get_port_details(const.PORT_DOWN)
297
291
298
292
def test_create_port_profile(self):
299
"""
300
Tests create port profile
301
"""
302
293
LOG.debug("UCSVICTestPlugin:test_create_port_profile() called\n")
294
new_network = db.network_create(self.tenant_id, self.net_name)
295
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
296
new_network[const.UUID])
297
new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
298
self._cisco_ucs_plugin._set_ucsm(self.device_ip)
303
299
new_port_profile = self._cisco_ucs_plugin._create_port_profile(
304
self.tenant_id, self.net_id, self.port_id,
305
self.vlan_name, self.vlan_id)
306
profile_name = self._cisco_ucs_plugin._get_profile_name(self.port_id)
300
self.tenant_id, new_network[const.UUID],
301
new_port[const.UUID], self.vlan_name,
302
self.vlan_id)
303
profile_name = self._cisco_ucs_plugin.\
304
_get_profile_name(new_port[const.UUID])
307
305
self.assertEqual(new_port_profile[const.PROFILE_NAME], profile_name)
308
306
self.assertEqual(new_port_profile[const.PROFILE_VLAN_NAME],
309
self.vlan_name)
307
self.vlan_name)
310
308
self.assertEqual(new_port_profile[const.PROFILE_VLAN_ID], self.vlan_id)
311
self._cisco_ucs_plugin._delete_port_profile(self.port_id, profile_name)
309
self._cisco_ucs_plugin._delete_port_profile(new_port[const.UUID],
310
profile_name)
312
311
313
312
def test_delete_port_profile(self):
314
"""
315
Tests delete port profile
316
"""
317
313
LOG.debug("UCSVICTestPlugin:test_delete_port_profile() called\n")
314
new_network = db.network_create(self.tenant_id, self.net_name)
315
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
316
new_network[const.UUID])
317
new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
318
self._cisco_ucs_plugin._set_ucsm(self.device_ip)
318
319
self._cisco_ucs_plugin._create_port_profile(
319
self.tenant_id, self.net_id, self.port_id, self.vlan_name,
320
self.vlan_id)
321
profile_name = self._cisco_ucs_plugin._get_profile_name(self.port_id)
320
self.tenant_id, new_network[const.UUID],
321
new_port[const.UUID], self.vlan_name,
322
self.vlan_id)
323
profile_name = self._cisco_ucs_plugin.\
324
_get_profile_name(new_port[const.UUID])
325
322
326
counter1 = self._cisco_ucs_plugin._port_profile_counter
323
self._cisco_ucs_plugin._delete_port_profile(self.port_id,
324
profile_name)
327
self._cisco_ucs_plugin._delete_port_profile(new_port[const.UUID],
328
profile_name)
325
329
counter2 = self._cisco_ucs_plugin._port_profile_counter
326
self.assertNotEqual(counter1, counter2)
330
self.assertEqual(counter1 - 1, counter2)
327
331
328
def _test_plug_interface(self, remote_interface_id):
332
def test_plug_interface(self, remote_interface_id=None,
333
new_vlanid=10, new_vlan_name='new_vlan'):
329
334
"""
330
335
Attaches a remote interface to the specified port on the
331
336
specified Virtual Network.
332
337
"""
333
338
LOG.debug("UCSVICTestPlugin:_test_plug_interface() called\n")
334
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
335
self.net_id, self.vlan_name,
336
self.vlan_id)
337
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
338
const.PORT_UP, self.port_id)
339
self._cisco_ucs_plugin.plug_interface(self.tenant_id, self.net_id,
340
self.port_id,
341
remote_interface_id)
342
port = self._cisco_ucs_plugin._get_port(
343
self.tenant_id, self.net_id, self.port_id)
344
self.assertEqual(port[const.ATTACHMENT], remote_interface_id)
345
port_profile = port[const.PORT_PROFILE]
346
new_vlan_name = self._cisco_ucs_plugin._get_vlan_name_for_network(
347
self.tenant_id, self.net_id)
348
new_vlan_id = self._cisco_ucs_plugin._get_vlan_id_for_network(
349
self.tenant_id, self.net_id)
350
self.assertEqual(port_profile[const.PROFILE_VLAN_NAME], new_vlan_name)
351
self.assertEqual(port_profile[const.PROFILE_VLAN_ID], new_vlan_id)
352
self.tearDownNetworkPortInterface(self.tenant_id, self.net_id,
353
self.port_id)
354
355
def test_plug_interface(self):
356
"""
357
Tests test plug interface
358
"""
359
self._test_plug_interface("4")
360
361
def _test_unplug_interface(self, remote_interface_id):
339
new_network = db.network_create(self.tenant_id, self.net_name)
340
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
341
new_network[const.UUID])
342
new_net_dict = self._cisco_ucs_plugin.create_network(
343
self.tenant_id, new_network[const.NETWORKNAME],
344
new_network[const.UUID], self.vlan_name, self.vlan_id,
345
device_ip=self.device_ip)
346
new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
347
port_dict = self._cisco_ucs_plugin.create_port(
348
self.tenant_id, new_net_dict[const.NET_ID],
349
const.PORT_UP, new_port[const.UUID],
350
device_ip=self.device_ip,
351
ucs_inventory=self._ucs_inventory,
352
least_rsvd_blade_dict=self._ucs_inventory.\
353
_get_least_reserved_blade())
354
cdb.update_vlan_binding(new_network[const.UUID],
355
str(new_vlanid), new_vlan_name)
356
port_bind = self._cisco_ucs_plugin.plug_interface(
357
self.tenant_id, new_net_dict[const.NET_ID],
358
port_dict[const.PORTID], remote_interface_id,
359
device_ip=self.device_ip)
360
self.assertEqual(port_bind[const.VLANNAME], new_vlan_name)
361
self.assertEqual(port_bind[const.VLANID], new_vlanid)
362
self.tearDownNetworkPortInterface(
363
self.tenant_id, new_net_dict[const.NET_ID],
364
new_port[const.UUID])
365
366
def test_unplug_interface(self, remote_interface_id=None,
367
new_vlanid=10, new_vlan_name='new_vlan'):
362
368
"""
363
369
Tests whether remote interface detaches from the specified port on the
364
370
specified Virtual Network.
365
371
"""
366
372
LOG.debug("UCSVICTestPlugin:_test_unplug_interface() called\n")
367
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
368
self.net_id, self.vlan_name,
369
self.vlan_id)
370
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
371
const.PORT_UP, self.port_id)
372
self._cisco_ucs_plugin.plug_interface(self.tenant_id, self.net_id,
373
self.port_id,
374
remote_interface_id)
375
self._cisco_ucs_plugin.unplug_interface(self.tenant_id, self.net_id,
376
self.port_id)
377
port = self._cisco_ucs_plugin._get_port(
378
self.tenant_id, self.net_id, self.port_id)
379
self.assertEqual(port[const.ATTACHMENT], None)
380
port_profile = port[const.PORT_PROFILE]
381
self.assertEqual(port_profile[const.PROFILE_VLAN_NAME],
382
conf.DEFAULT_VLAN_NAME)
383
self.assertEqual(port_profile[const.PROFILE_VLAN_ID],
384
conf.DEFAULT_VLAN_ID)
385
self.tearDownNetworkPort(self.tenant_id, self.net_id, self.port_id)
373
new_network = db.network_create(self.tenant_id, self.net_name)
374
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
375
new_network[const.UUID])
376
new_net_dict = self._cisco_ucs_plugin.create_network(
377
self.tenant_id, new_network[const.NETWORKNAME],
378
new_network[const.UUID], self.vlan_name, self.vlan_id,
379
device_ip=self.device_ip)
380
new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
381
port_dict = self._cisco_ucs_plugin.create_port(
382
self.tenant_id, new_net_dict[const.NET_ID],
383
const.PORT_UP, new_port[const.UUID],
384
device_ip=self.device_ip,
385
ucs_inventory=self._ucs_inventory,
386
least_rsvd_blade_dict=self._ucs_inventory.\
387
_get_least_reserved_blade())
388
cdb.update_vlan_binding(new_network[const.UUID],
389
str(new_vlanid), new_vlan_name)
390
self._cisco_ucs_plugin.plug_interface(
391
self.tenant_id, new_net_dict[const.NET_ID],
392
port_dict[const.PORTID], remote_interface_id,
393
device_ip=self.device_ip)
386
394
387
def test_unplug_interface(self):
388
"""
389
Tests unplug interface
390
"""
391
self._test_unplug_interface("4")
395
port_bind = self._cisco_ucs_plugin.unplug_interface(
396
self.tenant_id, new_net_dict[const.NET_ID],
397
port_dict[const.PORTID], device_ip=self.device_ip)
398
self.assertEqual(port_bind[const.VLANNAME], self.vlan_name)
399
self.assertEqual(port_bind[const.VLANID], self.vlan_id)
400
self.tearDownNetworkPortInterface(
401
self.tenant_id, new_net_dict[const.NET_ID],
402
new_port[const.UUID])
392
403
393
404
def test_get_vlan_name_for_network(self):
394
"""
395
Tests get vlan name for network
396
"""
397
405
LOG.debug("UCSVICTestPlugin:test_get_vlan_name_for_network() called\n")
398
net = self._cisco_ucs_plugin.create_network(
399
self.tenant_id, self.net_name, self.net_id,
400
self.vlan_name, self.vlan_id)
401
self.assertEqual(net[const.NET_VLAN_NAME], self.vlan_name)
402
self.tearDownNetwork(self.tenant_id, self.net_id)
406
new_network = db.network_create(self.tenant_id, self.net_name)
407
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
408
new_network[const.UUID])
409
vlan_bind_name = self._cisco_ucs_plugin._get_vlan_name_for_network(
410
self.tenant_id, new_network[const.UUID])
411
412
self.assertEqual(vlan_bind_name, self.vlan_name)
403
413
404
414
def test_get_vlan_id_for_network(self):
405
"""
406
Tests get vlan id for network
407
"""
408
415
LOG.debug("UCSVICTestPlugin:test_get_vlan_id_for_network() called\n")
409
net = self._cisco_ucs_plugin.create_network(
410
self.tenant_id, self.net_name, self.net_id, self.vlan_name,
411
self.vlan_id)
412
self.assertEqual(net[const.NET_VLAN_ID], self.vlan_id)
413
self.tearDownNetwork(self.tenant_id, self.net_id)
414
415
def test_get_network(self):
416
"""
417
Tests get network
418
"""
419
LOG.debug("UCSVICTestPlugin:test_get_network() called\n")
420
net = self._cisco_ucs_plugin.create_network(
421
self.tenant_id, self.net_name, self.net_id, self.vlan_name,
422
self.vlan_id)
423
self.assertEqual(net[const.NET_ID], self.net_id)
424
self.tearDownNetwork(self.tenant_id, self.net_id)
425
426
def test_get_port(self):
427
"""
428
Tests get port
429
"""
430
LOG.debug("UCSVICTestPlugin:test_get_port() called\n")
431
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
432
self.net_id, self.vlan_name,
433
self.vlan_id)
434
new_port_dict = self._cisco_ucs_plugin.create_port(
435
self.tenant_id, self.net_id,
436
const.PORT_UP, self.port_id)
437
self.assertEqual(new_port_dict[const.PORT_ID], self.port_id)
438
self.tearDownNetworkPort(self.tenant_id, self.net_id, self.port_id)
439
440
def test_get_network_NetworkNotFound(self):
441
"""
442
Tests get network not found
443
"""
416
new_network = db.network_create(self.tenant_id, self.net_name)
417
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
418
new_network[const.UUID])
419
vlan_bind_id = self._cisco_ucs_plugin._get_vlan_id_for_network(
420
self.tenant_id, new_network[const.UUID])
421
self.assertEqual(str(vlan_bind_id), self.vlan_id)
422
423
def test_show_network_NetworkNotFound(self):
444
424
self.assertRaises(exc.NetworkNotFound,
445
self._cisco_ucs_plugin._get_network,
446
self.tenant_id, self.net_id)
425
self._cisco_ucs_plugin.get_network_details,
426
self.tenant_id, self.net_id,
427
device_ip=self.device_ip)
447
428
448
429
def test_delete_network_NetworkNotFound(self):
449
"""
450
Tests delete network not found
451
"""
452
430
self.assertRaises(exc.NetworkNotFound,
453
431
self._cisco_ucs_plugin.delete_network,
454
self.tenant_id, self.net_id)
455
456
def test_delete_port_PortInUse(self):
457
"""
458
Tests delete port in use
459
"""
460
self._test_delete_port_PortInUse("4")
461
462
def _test_delete_port_PortInUse(self, remote_interface_id):
463
"""
464
Tests delete port in use
465
"""
466
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
467
self.net_id, self.vlan_name,
468
self.vlan_id)
469
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
470
const.PORT_UP, self.port_id)
471
self._cisco_ucs_plugin.plug_interface(self.tenant_id, self.net_id,
472
self.port_id,
473
remote_interface_id)
474
self.assertRaises(exc.PortInUse, self._cisco_ucs_plugin.delete_port,
475
self.tenant_id, self.net_id, self.port_id)
476
self.tearDownNetworkPortInterface(self.tenant_id, self.net_id,
477
self.port_id)
432
self.tenant_id, self.net_id,
433
device_ip=self.device_ip)
478
434
479
435
def test_delete_port_PortNotFound(self):
480
"""
481
Tests delete port not found
482
"""
483
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
484
self.net_id, self.vlan_name,
485
self.vlan_id)
486
self.assertRaises(exc.PortNotFound, self._cisco_ucs_plugin.delete_port,
487
self.tenant_id, self.net_id, self.port_id)
488
self.tearDownNetwork(self.tenant_id, self.net_id)
489
490
def test_plug_interface_PortInUse(self):
491
"""
492
Tests plug interface port in use
493
"""
494
self._test_plug_interface_PortInUse("6", "5")
495
496
def _test_plug_interface_PortInUse(self, remote_interface_id1,
497
remote_interface_id2):
498
"""
499
Tests plug interface port in use
500
"""
501
LOG.debug("UCSVICTestPlugin:_test_plug_interface_PortInUse() called\n")
502
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
503
self.net_id, self.vlan_name,
504
self.vlan_id)
505
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
506
const.PORT_UP, self.port_id)
507
self._cisco_ucs_plugin.plug_interface(self.tenant_id, self.net_id,
508
self.port_id,
509
remote_interface_id1)
510
self.assertRaises(exc.PortInUse, self._cisco_ucs_plugin.plug_interface,
511
self.tenant_id, self.net_id, self.port_id,
512
remote_interface_id2)
513
self.tearDownNetworkPortInterface(self.tenant_id, self.net_id,
514
self.port_id)
515
516
def test_attachment_exists(self):
517
"""
518
Tests attachment exists
519
"""
520
LOG.debug("UCSVICTestPlugin:testValidateAttachmentAlreadyAttached")
521
self._test_attachment_exists("4")
522
523
def _test_attachment_exists(self, remote_interface_id):
524
"""
525
Tests attachment exists
526
"""
527
LOG.debug("UCSVICTestPlugin:_test_validate_attachmentAlreadyAttached")
528
self._cisco_ucs_plugin.create_network(self.tenant_id, self.net_name,
529
self.net_id, self.vlan_name,
530
self.vlan_id)
531
self._cisco_ucs_plugin.create_port(self.tenant_id, self.net_id,
532
const.PORT_UP, self.port_id)
533
self._cisco_ucs_plugin.plug_interface(self.tenant_id, self.net_id,
534
self.port_id,
535
remote_interface_id)
536
self.assertRaises(
537
exc.PortInUse, self._cisco_ucs_plugin._validate_attachment,
538
self.tenant_id, self.net_id, self.port_id, remote_interface_id)
539
self.tearDownNetworkPortInterface(self.tenant_id, self.net_id,
540
self.port_id)
436
new_network = db.network_create(self.tenant_id, self.net_name)
437
cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
438
new_network[const.UUID])
439
new_net_dict = self._cisco_ucs_plugin.create_network(
440
self.tenant_id, new_network[const.NETWORKNAME],
441
new_network[const.UUID], self.vlan_name, self.vlan_id,
442
device_ip=self.device_ip)
443
444
self.assertRaises(c_exc.PortVnicNotFound,
445
self._cisco_ucs_plugin.delete_port,
446
self.tenant_id, new_net_dict[const.NET_ID],
447
self.port_id, device_ip=self.device_ip,
448
ucs_inventory=self._ucs_inventory,
449
chassis_id=self.chassis_id, blade_id=self.blade_id,
450
blade_intf_distinguished_name=self.\
451
blade_intf_distinguished_name,
452
least_rsvd_blade_dict=self._ucs_inventory.\
453
_get_least_reserved_blade())
454
455
self.tearDownNetwork(self.tenant_id, new_net_dict[const.NET_ID])
456
457
def tearDown(self):
458
"""Clear the test environment"""
459
# Remove database contents
460
db.clear_db()
541
461
542
462
def tearDownNetwork(self, tenant_id, net_id):
543
"""
544
Tear down network
545
"""
546
self._cisco_ucs_plugin.delete_network(tenant_id, net_id)
463
self._cisco_ucs_plugin.delete_network(tenant_id, net_id,
464
device_ip=self.device_ip)
547
465
548
466
def tearDownNetworkPort(self, tenant_id, net_id, port_id):
549
"""
550
Tear down network port
551
"""
552
self._cisco_ucs_plugin.delete_port(tenant_id, net_id,
553
port_id)
467
self._cisco_ucs_plugin.delete_port(
468
tenant_id, net_id, port_id, device_ip=self.device_ip,
469
ucs_inventory=self._ucs_inventory,
470
chassis_id=self.chassis_id, blade_id=self.blade_id,
471
blade_intf_distinguished_name=self.\
472
blade_intf_distinguished_name,
473
least_rsvd_blade_dict=self._ucs_inventory.\
474
_get_least_reserved_blade())
554
475
self.tearDownNetwork(tenant_id, net_id)
555
476
556
477
def tearDownNetworkPortInterface(self, tenant_id, net_id, port_id):
557
"""
558
Tear down network port interface
559
"""
560
self._cisco_ucs_plugin.unplug_interface(tenant_id, net_id,
561
port_id)
478
self._cisco_ucs_plugin.unplug_interface(
479
tenant_id, net_id, port_id,
480
device_ip=self.device_ip)
562
481
self.tearDownNetworkPort(tenant_id, net_id, port_id)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1