VMWare driver to use current nova.network.model

* Updated tests to use classes from nova.network.model instead of legacy
  "network,mapping" tuple.
* Modified vmwareapi/{driver,vif,vmops}.py to use classes from
  nova.network.model instead of legacy "network,mapping" tuple.

Fixes: bug 1112655
Change-Id: I7f4b39cd5add7d3cf7dcf485eb9855d0354f332c

3 files changed, 128 insertions, 40 deletions

diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index 74c786a86..e20a5a7b7 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -28,6 +28,7 @@ from nova import exception
 from nova import test
 import nova.tests.image.fake
 from nova.tests import matchers
+from nova.tests import utils
 from nova.tests.vmwareapi import db_fakes
 from nova.tests.vmwareapi import stubs
 from nova.virt.vmwareapi import driver
@@ -54,25 +55,7 @@ class VMwareAPIVMTestCase(test.TestCase):
         self.conn = driver.VMwareESXDriver(None, False)
         # NOTE(vish): none of the network plugging code is actually
         #             being tested
-        self.network_info = [({'bridge': 'fa0',
-                               'id': 0,
-                               'vlan': None,
-                               'bridge_interface': None,
-                               'injected': True},
-                          {'broadcast': '192.168.0.255',
-                           'id': 'foo',
-                           'dns': ['192.168.0.1'],
-                           'gateway': '192.168.0.1',
-                           'gateway_v6': 'dead:beef::1',
-                           'ip6s': [{'enabled': '1',
-                                     'ip': 'dead:beef::dcad:beff:feef:0',
-                                           'netmask': '64'}],
-                           'ips': [{'enabled': '1',
-                                    'ip': '192.168.0.100',
-                                    'netmask': '255.255.255.0'}],
-                           'label': 'fake',
-                           'mac': 'DE:AD:BE:EF:00:00',
-                           'rxtx_cap': 3})]
+        self.network_info = utils.get_test_network_info(legacy_model=False)
 
         self.image = {
             'id': 'c1c8ce3d-c2e0-4247-890c-ccf5cc1c004c',
diff --git a/nova/tests/test_vmwareapi_vmops.py b/nova/tests/test_vmwareapi_vmops.py
new file mode 100644
index 000000000..ad83cd21d
--- /dev/null
+++ b/nova/tests/test_vmwareapi_vmops.py
@@ -0,0 +1,62 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2013 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from nova.network import model as network_model
+from nova import test
+from nova.virt.vmwareapi import vmops
+
+
+class VMwareVMOpsTestCase(test.TestCase):
+    def setUp(self):
+        super(VMwareVMOpsTestCase, self).setUp()
+        subnet_4 = network_model.Subnet(cidr='192.168.0.1/24',
+                                        dns=[network_model.IP('192.168.0.1')],
+                                        gateway=
+                                            network_model.IP('192.168.0.1'),
+                                        ips=[
+                                            network_model.IP('192.168.0.100')],
+                                        routes=None)
+        subnet_6 = network_model.Subnet(cidr='dead:beef::1/64',
+                                        dns=None,
+                                        gateway=
+                                            network_model.IP('dead:beef::1'),
+                                        ips=[network_model.IP(
+                                            'dead:beef::dcad:beff:feef:0')],
+                                        routes=None)
+        network = network_model.Network(id=0,
+                                        bridge='fa0',
+                                        label='fake',
+                                        subnets=[subnet_4, subnet_6],
+                                        vlan=None,
+                                        bridge_interface=None,
+                                        injected=True)
+        self.network_info = network_model.NetworkInfo([
+                network_model.VIF(id=None,
+                                  address='DE:AD:BE:EF:00:00',
+                                  network=network,
+                                  type=None,
+                                  devname=None,
+                                  ovs_interfaceid=None,
+                                  rxtx_cap=3)
+                ])
+
+    def test_get_machine_id_str(self):
+        result = vmops.VMwareVMOps._get_machine_id_str(self.network_info)
+        print result
+        self.assertEqual(result,
+                         'DE:AD:BE:EF:00:00;192.168.0.100;255.255.255.0;'
+                         '192.168.0.1;192.168.0.255;192.168.0.1#')
diff --git a/nova/tests/utils.py b/nova/tests/utils.py
index a5d4b4712..56be3ab71 100644
--- a/nova/tests/utils.py
+++ b/nova/tests/utils.py
@@ -89,7 +89,7 @@ def get_test_instance(context=None, instance_type=None):
     return instance_ref
 
 
-def get_test_network_info(count=1):
+def get_test_network_info(count=1, legacy_model=True):
     ipv6 = CONF.use_ipv6
     fake = 'fake'
     fake_ip = '0.0.0.0/0'
@@ -98,26 +98,69 @@ def get_test_network_info(count=1):
     fake_netmask = '255.255.255.255'
     fake_vlan = 100
     fake_bridge_interface = 'eth0'
-    network = {'bridge': fake,
-               'cidr': fake_ip,
-               'cidr_v6': fake_ip,
-               'vlan': fake_vlan,
-               'bridge_interface': fake_bridge_interface,
-               'injected': False}
-    mapping = {'mac': fake,
-               'vif_type': network_model.VIF_TYPE_BRIDGE,
-               'vif_uuid': 'vif-xxx-yyy-zzz',
-               'dhcp_server': fake,
-               'dns': ['fake1', 'fake2'],
-               'gateway': fake,
-               'gateway_v6': fake,
-               'ips': [{'ip': fake_ip, 'netmask': fake_netmask},
-                       {'ip': fake_ip, 'netmask': fake_netmask}]}
-    if ipv6:
-        mapping['ip6s'] = [{'ip': fake_ip, 'netmask': fake_netmask},
-                           {'ip': fake_ip_2},
-                           {'ip': fake_ip_3}]
-    return [(network, mapping) for x in xrange(0, count)]
+
+    def legacy():
+        network = {'bridge': fake,
+                   'cidr': fake_ip,
+                   'cidr_v6': fake_ip,
+                   'vlan': fake_vlan,
+                   'bridge_interface': fake_bridge_interface,
+                   'injected': False}
+        mapping = {'mac': fake,
+                   'vif_type': network_model.VIF_TYPE_BRIDGE,
+                   'vif_uuid': 'vif-xxx-yyy-zzz',
+                   'dhcp_server': fake,
+                   'dns': ['fake1', 'fake2'],
+                   'gateway': fake,
+                   'gateway_v6': fake,
+                   'ips': [{'ip': fake_ip, 'netmask': fake_netmask},
+                           {'ip': fake_ip, 'netmask': fake_netmask}]}
+        if ipv6:
+            mapping['ip6s'] = [{'ip': fake_ip, 'netmask': fake_netmask},
+                               {'ip': fake_ip_2},
+                               {'ip': fake_ip_3}]
+        return network, mapping
+
+    def current():
+        fake_ip = '0.0.0.0'
+        subnet_4 = network_model.Subnet(cidr=fake_ip,
+                                        dns=[network_model.IP(fake_ip),
+                                             network_model.IP(fake_ip)],
+                                        gateway=network_model.IP(fake_ip),
+                                        ips=[network_model.IP(fake_ip),
+                                             network_model.IP(fake_ip)],
+                                        routes=None,
+                                        dhcp_server=network_model.IP(fake_ip))
+        subnet_6 = network_model.Subnet(cidr=fake_ip,
+                                        gateway=network_model.IP(fake_ip),
+                                        ips=[network_model.IP(fake_ip),
+                                             network_model.IP(fake_ip),
+                                             network_model.IP(fake_ip)],
+                                        routes=None,
+                                        version=6)
+        subnets = [subnet_4]
+        if ipv6:
+            subnets.append(subnet_6)
+        network = network_model.Network(id=None,
+                                        bridge=fake,
+                                        label=None,
+                                        subnets=subnets,
+                                        vlan=fake_vlan,
+                                        bridge_interface=fake_bridge_interface,
+                                        injected=False)
+        vif = network_model.VIF(id='vif-xxx-yyy-zzz',
+                                address=fake,
+                                network=network,
+                                type=network_model.VIF_TYPE_BRIDGE,
+                                devname=None,
+                                ovs_interfaceid=None)
+
+        return vif
+
+    if legacy_model:
+        return [legacy() for x in xrange(0, count)]
+    else:
+        return network_model.NetworkInfo([current() for x in xrange(0, count)])
 
 
 def is_osx():