← Back to branch summary

~ubuntu-branches/ubuntu/vivid/neutron/vivid-updates

« back to all changes in this revision

Viewing changes to neutron/tests/unit/nuage/fake_nuageclient.py

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2015-03-30 11:17:19 UTC
  • mfrom: (1.1.21)
  • Revision ID: package-import@ubuntu.com-20150330111719-h0gx7233p4jkkgfh
Tags: 1:2015.1~b3-0ubuntu1
https://launchpad.net/bugs/1263539
* New upstream milestone release:
  - d/control: Align version requirements with upstream.
  - d/control: Add new dependency on oslo-log.
  - d/p/*: Rebase.
  - d/control,d/neutron-plugin-hyperv*: Dropped, decomposed into
    separate project upstream.
  - d/control,d/neutron-plugin-openflow*: Dropped, decomposed into
    separate project upstream.
  - d/neutron-common.install: Add neutron-rootwrap-daemon and 
    neutron-keepalived-state-change binaries.
  - d/rules: Ignore neutron-hyperv-agent when installing; only for Windows.
  - d/neutron-plugin-cisco.install: Drop neutron-cisco-cfg-agent as
    decomposed into separate project upstream.
  - d/neutron-plugin-vmware.install: Drop neutron-check-nsx-config and
    neutron-nsx-manage as decomposed into separate project upstream.
  - d/control: Add dependency on python-neutron-fwaas to neutron-l3-agent.
* d/pydist-overrides: Add overrides for oslo packages.
* d/control: Fixup type in package description (LP: #1263539).
* d/p/fixup-driver-test-execution.patch: Cherry pick fix from upstream VCS
  to support unit test exection in out-of-tree vendor drivers.
* d/neutron-common.postinst: Allow general access to /etc/neutron but limit
  access to root/neutron to /etc/neutron/neutron.conf to support execution
  of unit tests in decomposed vendor drivers.
* d/control: Add dependency on python-neutron-fwaas to neutron-l3-agent
  package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
neutron/tests/unit/nuage/fake_nuageclient.py
1
 
# Copyright 2014 Alcatel-Lucent USA Inc.
2
 
#
3
 
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
4
 
#    not use this file except in compliance with the License. You may obtain
5
 
#    a copy of the License at
6
 
#
7
 
#         http://www.apache.org/licenses/LICENSE-2.0
8
 
#
9
 
#    Unless required by applicable law or agreed to in writing, software
10
 
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11
 
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12
 
#    License for the specific language governing permissions and limitations
13
 
#    under the License.
14
 
 
15
 
from neutron.openstack.common import uuidutils
16
 
 
17
 
 
18
 
class FakeNuageClient(object):
19
 
    def __init__(self, server, base_uri, serverssl,
20
 
                 serverauth, auth_resource, organization):
21
 
        pass
22
 
 
23
 
    def rest_call(self, action, resource, data, extra_headers=None):
24
 
        pass
25
 
 
26
 
    def vms_on_l2domain(self, l2dom_id):
27
 
        pass
28
 
 
29
 
    def vms_on_subnet(self, subnet_id):
30
 
        pass
31
 
 
32
 
    def create_subnet(self, neutron_subnet, params):
33
 
        nuage_subnet = {
34
 
            'nuage_l2template_id': uuidutils.generate_uuid(),
35
 
            'nuage_userid': uuidutils.generate_uuid(),
36
 
            'nuage_groupid': uuidutils.generate_uuid(),
37
 
            'nuage_l2domain_id': uuidutils.generate_uuid()
38
 
        }
39
 
        return nuage_subnet
40
 
 
41
 
    def update_subnet(self, neutron_subnet, params):
42
 
        pass
43
 
 
44
 
    def delete_subnet(self, id):
45
 
        pass
46
 
 
47
 
    def create_router(self, neutron_router, router, params):
48
 
        nuage_router = {
49
 
            'nuage_userid': uuidutils.generate_uuid(),
50
 
            'nuage_groupid': uuidutils.generate_uuid(),
51
 
            'nuage_domain_id': uuidutils.generate_uuid(),
52
 
            'nuage_def_zone_id': uuidutils.generate_uuid(),
53
 
        }
54
 
        return nuage_router
55
 
 
56
 
    def delete_router(self, id):
57
 
        pass
58
 
 
59
 
    def delete_user(self, id):
60
 
        pass
61
 
 
62
 
    def delete_group(self, id):
63
 
        pass
64
 
 
65
 
    def create_domain_subnet(self, neutron_subnet, params):
66
 
        pass
67
 
 
68
 
    def delete_domain_subnet(self, id):
69
 
        pass
70
 
 
71
 
    def create_net_partition(self, params):
72
 
        fake_net_partition = {
73
 
            'nuage_entid': uuidutils.generate_uuid(),
74
 
            'l3dom_id': uuidutils.generate_uuid(),
75
 
            'l2dom_id': uuidutils.generate_uuid(),
76
 
        }
77
 
        return fake_net_partition
78
 
 
79
 
    def get_def_netpartition_data(self, default_net_part):
80
 
        if default_net_part == 'default_test_np':
81
 
            fake_defnetpart_data = {
82
 
                'np_id': uuidutils.generate_uuid(),
83
 
                'l3dom_tid': uuidutils.generate_uuid(),
84
 
                'l2dom_tid': uuidutils.generate_uuid(),
85
 
            }
86
 
            return fake_defnetpart_data
87
 
 
88
 
    def get_net_partition_id_by_name(self, name):
89
 
        return uuidutils.generate_uuid()
90
 
 
91
 
    def delete_net_partition(self, id, l3dom_id=None, l2dom_id=None):
92
 
        pass
93
 
 
94
 
    def check_del_def_net_partition(self, ent_name):
95
 
        pass
96
 
 
97
 
    def create_vms(self, params):
98
 
        pass
99
 
 
100
 
    def delete_vms(self, params):
101
 
        pass
102
 
 
103
 
    def create_nuage_staticroute(self, params):
104
 
        return uuidutils.generate_uuid()
105
 
 
106
 
    def delete_nuage_staticroute(self, id):
107
 
        pass
108
 
 
109
 
    def create_nuage_sharedresource(self, params):
110
 
        return uuidutils.generate_uuid()
111
 
 
112
 
    def delete_nuage_sharedresource(self, id):
113
 
        pass
114
 
 
115
 
    def create_nuage_floatingip(self, params):
116
 
        return uuidutils.generate_uuid()
117
 
 
118
 
    def delete_nuage_floatingip(self, id):
119
 
        pass
120
 
 
121
 
    def update_nuage_vm_vport(self, params):
122
 
        pass
123
 
 
124
 
    def get_nuage_fip_pool_by_id(self, net_id):
125
 
        result = {
126
 
            'nuage_fip_pool_id': uuidutils.generate_uuid()
127
 
        }
128
 
        return result
129
 
 
130
 
    def get_nuage_fip_by_id(self, params):
131
 
        if 'neutron_fip' in params:
132
 
            neutron_fip = params['neutron_fip']
133
 
            if (neutron_fip['floating_ip_address'] == '12.0.0.3' and
134
 
                neutron_fip['fixed_ip_address'] == '10.0.1.2') or (
135
 
                    neutron_fip['floating_ip_address'] == '12.0.0.5' and
136
 
                    neutron_fip['fixed_ip_address'] == '10.0.1.3'):
137
 
                result = {
138
 
                    'nuage_fip_id': '1',
139
 
                    'nuage_parent_id': '1'
140
 
                }
141
 
                return result
142
 
 
143
 
    def get_nuage_port_by_id(self, params):
144
 
        if params.get('nuage_fip_id') == '1':
145
 
            domain_id = uuidutils.generate_uuid()
146
 
        else:
147
 
            if 'nuage_router_id' in params:
148
 
                domain_id = params['nuage_router_id']
149
 
            else:
150
 
                return
151
 
 
152
 
        result = {
153
 
            'nuage_vif_id': uuidutils.generate_uuid(),
154
 
            'nuage_vport_id': uuidutils.generate_uuid(),
155
 
            'nuage_domain_id': domain_id
156
 
        }
157
 
 
158
 
        return result
159
 
 
160
 
    def get_zone_by_routerid(self, neutron_router_id):
161
 
        result = {
162
 
            'nuage_zone_id': uuidutils.generate_uuid()
163
 
        }
164
 
        return result
165
 
 
166
 
    def get_usergroup(self, tenant, net_partition_id):
167
 
        return uuidutils.generate_uuid(), uuidutils.generate_uuid()
168
 
 
169
 
    def get_sg_vptag_mapping(self, id):
170
 
        pass
171
 
 
172
 
    def validate_nuage_sg_rule_definition(self, params):
173
 
        pass
174
 
 
175
 
    def create_nuage_sgrule(self, params):
176
 
        pass
177
 
 
178
 
    def update_nuage_vport(self, params):
179
 
        pass
180
 
 
181
 
    def delete_nuage_sgrule(self, params):
182
 
        pass
183
 
 
184
 
    def delete_nuage_secgroup(self, params):
185
 
        pass
186
 
 
187
 
    def process_port_create_security_group(self, params):
188
 
        pass
189
 
 
190
 
    def delete_port_security_group_bindings(self, params):
191
 
        pass
192
 
 
193
 
    def validate_provider_network(self, net_type, phy_net, vlan_id):
194
 
        pass
195
 
 
196
 
    def remove_router_interface(self, params):
197
 
        pass
198
 
 
199
 
    def get_resources_to_sync(self, data):
200
 
        netpart_id_list = []
201
 
        for netpart in data['netpartition']:
202
 
            netpart_id_list.append(netpart['id'])
203
 
 
204
 
        netpart_dict = {
205
 
            'add': netpart_id_list,
206
 
            'sync': []
207
 
        }
208
 
 
209
 
        subn_id_list = []
210
 
        if data['subnet']:
211
 
            subn_id_list.append(data['subnet'][0])
212
 
 
213
 
        l2domain_dict = {
214
 
            'add': subn_id_list
215
 
        }
216
 
 
217
 
        rtr_id_list = []
218
 
        if data['router']:
219
 
            rtr_id_list.append(data['router'][0])
220
 
 
221
 
        domain_dict = {
222
 
            'add': rtr_id_list
223
 
        }
224
 
 
225
 
        domain_subn_id = uuidutils.generate_uuid()
226
 
 
227
 
        result = {
228
 
            'netpartition': netpart_dict,
229
 
            'l2domain': l2domain_dict,
230
 
            'domain': domain_dict,
231
 
            'domainsubnet': {'add': [domain_subn_id]},
232
 
            'sharednetwork': {'add': [uuidutils.generate_uuid()]},
233
 
            'route': {'add': []},
234
 
            'security': {
235
 
                'secgroup': {
236
 
                    'l2domain': {'add': {
237
 
                        uuidutils.generate_uuid(): [uuidutils.generate_uuid()]
238
 
                    }},
239
 
                    'domain': {'add': {
240
 
                        uuidutils.generate_uuid(): [uuidutils.generate_uuid()]
241
 
                    }}
242
 
                },
243
 
                'secgrouprule': {
244
 
                    'l2domain': {'add': [uuidutils.generate_uuid()]},
245
 
                    'domain': {'add': [uuidutils.generate_uuid()]}
246
 
                },
247
 
            },
248
 
            'port': {
249
 
                'vm': [uuidutils.generate_uuid()],
250
 
                'sub_rtr_intf_port_dict': {
251
 
                    domain_subn_id: uuidutils.generate_uuid()
252
 
                },
253
 
                'secgroup': [uuidutils.generate_uuid()]
254
 
            },
255
 
            'subl2dommapping': [uuidutils.generate_uuid()],
256
 
            'fip': {
257
 
                'add': [uuidutils.generate_uuid()],
258
 
                'associate': [uuidutils.generate_uuid()],
259
 
                'disassociate': [uuidutils.generate_uuid()]
260
 
            }
261
 
        }
262
 
        return result
263
 
 
264
 
    def create_netpart(self, netpart, fip_quota):
265
 
        if netpart['name'] == 'sync-new-netpartition':
266
 
            oldid = netpart['id']
267
 
            netpart['id'] = 'a917924f-3139-4bdb-a4c3-ea7c8011582f'
268
 
            netpart = {
269
 
                oldid: netpart
270
 
            }
271
 
            return netpart
272
 
        return {}
273
 
 
274
 
    def create_sharednetwork(self, subnet):
275
 
        pass
276
 
 
277
 
    def create_l2domain(self, netpart_id, subnet):
278
 
        subl2dom = {
279
 
            'subnet_id': subnet['id'],
280
 
            'nuage_subnet_id': '52daa465-cf33-4efd-91d3-f5bc2aebd',
281
 
            'net_partition_id': netpart_id,
282
 
            'nuage_l2dom_tmplt_id': uuidutils.generate_uuid(),
283
 
            'nuage_user_id': uuidutils.generate_uuid(),
284
 
            'nuage_group_id': uuidutils.generate_uuid(),
285
 
        }
286
 
 
287
 
        return subl2dom
288
 
 
289
 
    def create_domain(self, netpart, router):
290
 
        entrtr = {
291
 
            'router_id': router['id'],
292
 
            'nuage_router_id': '2d782c02-b88e-44ad-a79b-4bdf11f7df3d',
293
 
            'net_partition_id': netpart['id']
294
 
        }
295
 
 
296
 
        return entrtr
297
 
 
298
 
    def create_domainsubnet(self, subnet, ports):
299
 
        pass
300
 
 
301
 
    def create_route(self, route):
302
 
        pass
303
 
 
304
 
    def create_vm(self, port):
305
 
        pass
306
 
 
307
 
    def create_security_group(self, secgrp, ports):
308
 
        pass
309
 
 
310
 
    def create_security_group_rule(self, secgrprule):
311
 
        pass
312
 
 
313
 
    def create_fip(self, fip, ipalloc):
314
 
        pass
315
 
 
316
 
    def associate_fip(self, fip):
317
 
        pass
318
 
 
319
 
    def disassociate_fip(self, fip):
320
 
        pass