Python get_ofc_itemの例

コード例 #1

 def testc_delete_ofc_tenant(self):
     """test delete ofc_tenant."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t))
     self.ofc.delete_ofc_tenant(self.ctx, t)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t))

コード例 #2

ファイル: test_ofc_manager.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

 def testc_delete_ofc_tenant(self):
     """test delete ofc_tenant."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t))
     self.ofc.delete_ofc_tenant(self.ctx, t)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t))

コード例 #3

ファイル: test_ofc_manager.py プロジェクト: AsherBond/quantum

 def test_delete_ofc_router(self):
     """test delete ofc_router"""
     t, r, _n = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_router(self.ctx, t, r)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))
     self.ofc.delete_ofc_router(self.ctx, r, {'tenant_id': t})
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_network', r))

コード例 #4

ファイル: test_ofc_manager.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

 def testa_create_ofc_tenant(self):
     """test create ofc_tenant."""
     t, n, p, f, none = self.get_random_params()
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t))
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t))
     tenant = ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t)
     self.assertEqual(tenant.ofc_id, "ofc-" + t[:-4])

コード例 #5

ファイル: test_ofc_manager.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

 def testf_delete_ofc_network(self):
     """test delete ofc_network."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))
     self.ofc.delete_ofc_network(self.ctx, n, {'tenant_id': t})
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))

コード例 #6

 def testf_delete_ofc_network(self):
     """test delete ofc_network."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))
     self.ofc.delete_ofc_network(self.ctx, n, {'tenant_id': t})
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))

コード例 #7

 def test_delete_ofc_router(self):
     """test delete ofc_router"""
     t, r, _n = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_router(self.ctx, t, r)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))
     self.ofc.delete_ofc_router(self.ctx, r, {'tenant_id': t})
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_network', r))

コード例 #8

 def testa_create_ofc_tenant(self):
     """test create ofc_tenant."""
     t, n, p, f, none = self.get_random_params()
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t))
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t))
     tenant = ndb.get_ofc_item(self.ctx.session, 'ofc_tenant', t)
     self.assertEqual(tenant.ofc_id, "ofc-" + t[:-4])

コード例 #9

 def testd_create_ofc_network(self):
     """test create ofc_network."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))
     self.ofc.create_ofc_network(self.ctx, t, n)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))
     network = ndb.get_ofc_item(self.ctx.session, 'ofc_network', n)
     self.assertEqual(network.ofc_id, "ofc-" + n[:-4])

コード例 #10

ファイル: test_ofc_manager.py プロジェクト: AsherBond/quantum

 def test_create_ofc_router(self):
     """test create ofc_router"""
     t, r, _n = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))
     self.ofc.create_ofc_router(self.ctx, t, r, 'test router')
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))
     router = ndb.get_ofc_item(self.ctx.session, 'ofc_router', r)
     self.assertEqual(router.ofc_id, "ofc-" + r[:-4])

コード例 #11

 def test_create_ofc_router(self):
     """test create ofc_router"""
     t, r, _n = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))
     self.ofc.create_ofc_router(self.ctx, t, r, 'test router')
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))
     router = ndb.get_ofc_item(self.ctx.session, 'ofc_router', r)
     self.assertEqual(router.ofc_id, "ofc-" + r[:-4])

コード例 #12

ファイル: test_ofc_manager.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

 def testd_create_ofc_network(self):
     """test create ofc_network."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))
     self.ofc.create_ofc_network(self.ctx, t, n)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))
     network = ndb.get_ofc_item(self.ctx.session, 'ofc_network', n)
     self.assertEqual(network.ofc_id, "ofc-" + n[:-4])

コード例 #13

ファイル: test_db.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

    def testb_get_ofc_item(self):
        """test get OFC item."""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        tenant = ndb.get_ofc_item(self.session, 'ofc_tenant', q)
        self.assertEqual(tenant.ofc_id, o)
        self.assertEqual(tenant.quantum_id, q)

        tenant_none = ndb.get_ofc_item(self.session, 'ofc_tenant', n)
        self.assertEqual(None, tenant_none)

コード例 #14

ファイル: test_db.py プロジェクト: rhel-osp/neutron

    def testb_get_ofc_item(self):
        """test get OFC item."""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        tenant = ndb.get_ofc_item(self.session, 'ofc_tenant', q)
        self.assertEqual(tenant.ofc_id, o)
        self.assertEqual(tenant.quantum_id, q)

        tenant_none = ndb.get_ofc_item(self.session, 'ofc_tenant', n)
        self.assertEqual(None, tenant_none)

コード例 #15

ファイル: test_db.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

    def test_add_ofc_item_old(self):
        o, q, n = self.get_ofc_item_random_params()
        ret = ndb.add_ofc_item(self.session, 'ofc_tenant', q, o, self.OLD)
        self.assertEqual(ret.id, o)
        self.assertEqual(ret.quantum_id, q)

        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, self.NEW)
        self.assertEqual(ret, None)
        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, self.OLD)
        self.assertEqual(ret.id, o)
        self.assertEqual(ret.quantum_id, q)

コード例 #16

ファイル: test_db.py プロジェクト: rhel-osp/neutron

    def test_add_ofc_item_old(self):
        o, q, n = self.get_ofc_item_random_params()
        ret = ndb.add_ofc_item(self.session, 'ofc_tenant', q, o, self.OLD)
        self.assertEqual(ret.id, o)
        self.assertEqual(ret.quantum_id, q)

        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, self.NEW)
        self.assertEqual(ret, None)
        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, self.OLD)
        self.assertEqual(ret.id, o)
        self.assertEqual(ret.quantum_id, q)

コード例 #17

ファイル: test_ofc_manager.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

 def testi_delete_ofc_port(self):
     """test delete ofc_port."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     ndb.add_portinfo(self.ctx.session, p, "0xabc", 3, 65535,
                      "00:13:22:33:44:55")
     port = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_port(self.ctx, p, port)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     self.ofc.delete_ofc_port(self.ctx, p, port)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))

コード例 #18

 def testi_delete_ofc_port(self):
     """test delete ofc_port."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     get_portinfo = self._mock_get_portinfo(p)
     port = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_port(self.ctx, p, port)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     self.ofc.delete_ofc_port(self.ctx, p, port)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     get_portinfo.assert_called_once_with(mock.ANY, p)

コード例 #19

ファイル: test_ofc_manager.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

 def testl_delete_ofc_packet_filter(self):
     """test delete ofc_filter."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     pf = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_packet_filter(self.ctx, f, pf)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session,
                                      'ofc_packet_filter', f))
     self.ofc.delete_ofc_packet_filter(self.ctx, f)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session,
                                       'ofc_packet_filter', f))

コード例 #20

 def testi_delete_ofc_port(self):
     """test delete ofc_port."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     ndb.add_portinfo(self.ctx.session, p, "0xabc", 3, 65535,
                      "00:13:22:33:44:55")
     port = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_port(self.ctx, p, port)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     self.ofc.delete_ofc_port(self.ctx, p, port)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))

コード例 #21

ファイル: test_ofc_manager.py プロジェクト: AsherBond/quantum

 def testi_delete_ofc_port(self):
     """test delete ofc_port."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     get_portinfo = self._mock_get_portinfo(p)
     port = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_port(self.ctx, p, port)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     self.ofc.delete_ofc_port(self.ctx, p, port)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     get_portinfo.assert_called_once_with(mock.ANY, p)

コード例 #22

 def testl_delete_ofc_packet_filter(self):
     """test delete ofc_filter."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     pf = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_packet_filter(self.ctx, f, pf)
     self.assertTrue(
         ndb.get_ofc_item(self.ctx.session, 'ofc_packet_filter', f))
     self.ofc.delete_ofc_packet_filter(self.ctx, f)
     self.assertFalse(
         ndb.get_ofc_item(self.ctx.session, 'ofc_packet_filter', f))

コード例 #23

 def testg_create_ofc_port(self):
     """test create ofc_port."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     ndb.add_portinfo(self.ctx.session, p, "0xabc", 1, 65535,
                      "00:11:22:33:44:55")
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     port = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_port(self.ctx, p, port)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     port = ndb.get_ofc_item(self.ctx.session, 'ofc_port', p)
     self.assertEqual(port.ofc_id, "ofc-" + p[:-4])

コード例 #24

ファイル: test_ofc_manager.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

 def testj_create_ofc_packet_filter(self):
     """test create ofc_filter."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session,
                                       'ofc_packet_filter', f))
     pf = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_packet_filter(self.ctx, f, pf)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session,
                                      'ofc_packet_filter', f))
     _filter = ndb.get_ofc_item(self.ctx.session, 'ofc_packet_filter', f)
     self.assertEqual(_filter.ofc_id, "ofc-" + f[:-4])

コード例 #25

ファイル: test_ofc_manager.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

 def testg_create_ofc_port(self):
     """test create ofc_port."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     ndb.add_portinfo(self.ctx.session, p, "0xabc", 1, 65535,
                      "00:11:22:33:44:55")
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     port = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_port(self.ctx, p, port)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     port = ndb.get_ofc_item(self.ctx.session, 'ofc_port', p)
     self.assertEqual(port.ofc_id, "ofc-" + p[:-4])

コード例 #26

 def testj_create_ofc_packet_filter(self):
     """test create ofc_filter."""
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     self.assertFalse(
         ndb.get_ofc_item(self.ctx.session, 'ofc_packet_filter', f))
     pf = {'tenant_id': t, 'network_id': n}
     self.ofc.create_ofc_packet_filter(self.ctx, f, pf)
     self.assertTrue(
         ndb.get_ofc_item(self.ctx.session, 'ofc_packet_filter', f))
     _filter = ndb.get_ofc_item(self.ctx.session, 'ofc_packet_filter', f)
     self.assertEqual(_filter.ofc_id, "ofc-" + f[:-4])

コード例 #27

ファイル: test_db.py プロジェクト: nabilmaad/neutron

    def test_del_ofc_item(self):
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        self.assertTrue(ndb.del_ofc_item(self.session, 'ofc_tenant', q))

        self.assertIsNone(ndb.get_ofc_item(self.session, 'ofc_tenant', q))
        self.assertIsNone(ndb.find_ofc_item(self.session, 'ofc_tenant', o))

コード例 #28

ファイル: test_db.py プロジェクト: CiscoSystems/neutron

    def test_del_ofc_item(self):
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        self.assertTrue(ndb.del_ofc_item(self.session, 'ofc_tenant', q))

        self.assertIsNone(ndb.get_ofc_item(self.session, 'ofc_tenant', q))
        self.assertIsNone(ndb.find_ofc_item(self.session, 'ofc_tenant', o))

コード例 #29

    def test_router_route(self):
        t, r, _n = self.get_random_params()
        self.ofc.create_ofc_tenant(self.ctx, t)
        self.ofc.create_ofc_router(self.ctx, t, r)
        self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))

        routes = [{'destination': '2.2.2.0/24', 'nexthop': '1.1.1.10'}]
        self.ofc.update_ofc_router_route(self.ctx, r, routes)
        self.assertEqual(len(self.ofc.driver.ofc_router_route_dict), 1)

        routes = [{
            'destination': '3.3.3.0/24',
            'nexthop': '1.1.1.11'
        }, {
            'destination': '4.4.4.0/24',
            'nexthop': '1.1.1.11'
        }]
        self.ofc.update_ofc_router_route(self.ctx, r, routes)
        self.assertEqual(len(self.ofc.driver.ofc_router_route_dict), 2)

        routes = [{'destination': '2.2.2.0/24', 'nexthop': '1.1.1.10'}]
        self.ofc.update_ofc_router_route(self.ctx, r, routes)
        self.assertEqual(len(self.ofc.driver.ofc_router_route_dict), 1)

        routes = []
        self.ofc.update_ofc_router_route(self.ctx, r, routes)
        self.assertEqual(len(self.ofc.driver.ofc_router_route_dict), 0)

コード例 #30

ファイル: test_db.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

    def testb_exists_ofc_item(self):
        """test get OFC d."""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        ret = ndb.exists_ofc_item(self.session, 'ofc_tenant', q)
        self.assertTrue(ret)

        tenant_none = ndb.get_ofc_item(self.session, 'ofc_tenant', n)
        self.assertEqual(None, tenant_none)

コード例 #31

ファイル: test_db.py プロジェクト: ChengZuo/neutron

    def testb_get_ofc_id(self):
        """test get OFC d."""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        tenant_id = ndb.get_ofc_id(self.session, 'ofc_tenant', q)
        self.assertEqual(tenant_id, o)

        tenant_none = ndb.get_ofc_item(self.session, 'ofc_tenant', n)
        self.assertIsNone(tenant_none)

コード例 #32

ファイル: test_db.py プロジェクト: rhel-osp/neutron

    def testb_exists_ofc_item(self):
        """test get OFC d."""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        ret = ndb.exists_ofc_item(self.session, 'ofc_tenant', q)
        self.assertTrue(ret)

        tenant_none = ndb.get_ofc_item(self.session, 'ofc_tenant', n)
        self.assertEqual(None, tenant_none)

コード例 #33

ファイル: test_db.py プロジェクト: yuhui7red/neutron

    def testb_get_ofc_id(self):
        """test get OFC d."""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        tenant_id = ndb.get_ofc_id(self.session, 'ofc_tenant', q)
        self.assertEqual(tenant_id, o)

        tenant_none = ndb.get_ofc_item(self.session, 'ofc_tenant', n)
        self.assertIsNone(tenant_none)

コード例 #34

ファイル: test_ofc_manager.py プロジェクト: AsherBond/quantum

    def test_router_interface(self):
        t, r, n = self.get_random_params()
        self.ofc.create_ofc_tenant(self.ctx, t)
        self.ofc.create_ofc_router(self.ctx, t, r)
        self.ofc.create_ofc_network(self.ctx, t, n)
        self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))
        self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))

        p = {'id': uuidutils.generate_uuid(),
             'network_id': n, 'ip_address': '10.1.1.1', 'cidr': '10.1.0.0/20',
             'mac_address': '11:22:33:44:55:66'}
        self.ofc.add_ofc_router_interface(self.ctx, r, p['id'], p)
        self.assertTrue(ndb.get_ofc_item(self.ctx.session,
                                         'ofc_port', p['id']))
        self.ofc.delete_ofc_router_interface(self.ctx, r, p['id'])
        self.assertFalse(ndb.get_ofc_item(self.ctx.session,
                                          'ofc_port', p['id']))
        self.ofc.delete_ofc_router(self.ctx, r, {'tenant_id': t})
        self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_network', r))

コード例 #35

ファイル: test_ofc_manager.py プロジェクト: Juniper/neutron

    def test_router_interface(self):
        t, r, n = self.get_random_params()
        self.ofc.create_ofc_tenant(self.ctx, t)
        self.ofc.create_ofc_router(self.ctx, t, r)
        self.ofc.create_ofc_network(self.ctx, t, n)
        self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))
        self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_network', n))

        p = {'id': uuidutils.generate_uuid(),
             'network_id': n, 'ip_address': '10.1.1.1', 'cidr': '10.1.0.0/20',
             'mac_address': '11:22:33:44:55:66'}
        self.ofc.add_ofc_router_interface(self.ctx, r, p['id'], p)
        self.assertTrue(ndb.get_ofc_item(self.ctx.session,
                                         'ofc_port', p['id']))
        self.ofc.delete_ofc_router_interface(self.ctx, r, p['id'])
        self.assertFalse(ndb.get_ofc_item(self.ctx.session,
                                          'ofc_port', p['id']))
        self.ofc.delete_ofc_router(self.ctx, r, {'tenant_id': t})
        self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_network', r))

コード例 #36

ファイル: test_db.py プロジェクト: rhel-osp/neutron

    def testc_del_ofc_item(self):
        """test delete OFC item."""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        ndb.del_ofc_item(self.session, 'ofc_tenant', q)

        tenant_none = ndb.get_ofc_item(self.session, 'ofc_tenant', q)
        self.assertEqual(None, tenant_none)
        tenant_none = ndb.find_ofc_item(self.session, 'ofc_tenant', o)
        self.assertEqual(None, tenant_none)

コード例 #37

ファイル: test_db.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

    def _check_delete_ofc_item(self, mode, detect_mode=False):
        o, q, n = self.get_ofc_item_random_params()
        ret = ndb.add_ofc_item(self.session, 'ofc_tenant', q, o, mode)
        ofc_id = ret.ofc_id if mode == self.NEW else ret.id
        self.assertEqual(ofc_id, o)
        self.assertEqual(ret.quantum_id, q)
        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, mode)
        ofc_id = ret.ofc_id if mode == self.NEW else ret.id
        self.assertEqual(ofc_id, o)
        self.assertEqual(ret.quantum_id, q)

        if detect_mode:
            ndb.del_ofc_item_lookup_both(self.session, 'ofc_tenant', q)
        else:
            ndb.del_ofc_item(self.session, 'ofc_tenant', q, mode)

        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, self.NEW)
        self.assertEqual(ret, None)
        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, self.OLD)
        self.assertEqual(ret, None)

コード例 #38

ファイル: test_ofc_manager.py プロジェクト: AsherBond/quantum

 def _test_create_ofc_port(self, with_filter=False):
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     get_portinfo = self._mock_get_portinfo(p)
     port = {'tenant_id': t, 'network_id': n}
     if with_filter:
         _filters = ['filter1', 'filter2']
         self.plugin.get_packet_filters_for_port.return_value = _filters
     self.ofc.create_ofc_port(self.ctx, p, port)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     port = ndb.get_ofc_item(self.ctx.session, 'ofc_port', p)
     self.assertEqual(port.ofc_id, "ofc-" + p[:-4])
     get_portinfo.assert_called_once_with(mock.ANY, p)
     portval = self.ofc.driver.ofc_port_dict[port.ofc_id]
     if with_filter:
         self.assertEqual(_filters, portval['filters'])
     else:
         self.assertFalse('filters' in portval)

コード例 #39

ファイル: test_db.py プロジェクト: rhel-osp/neutron

    def _check_delete_ofc_item(self, mode, detect_mode=False):
        o, q, n = self.get_ofc_item_random_params()
        ret = ndb.add_ofc_item(self.session, 'ofc_tenant', q, o, mode)
        ofc_id = ret.ofc_id if mode == self.NEW else ret.id
        self.assertEqual(ofc_id, o)
        self.assertEqual(ret.quantum_id, q)
        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, mode)
        ofc_id = ret.ofc_id if mode == self.NEW else ret.id
        self.assertEqual(ofc_id, o)
        self.assertEqual(ret.quantum_id, q)

        if detect_mode:
            ndb.del_ofc_item_lookup_both(self.session, 'ofc_tenant', q)
        else:
            ndb.del_ofc_item(self.session, 'ofc_tenant', q, mode)

        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, self.NEW)
        self.assertEqual(ret, None)
        ret = ndb.get_ofc_item(self.session, 'ofc_tenant', q, self.OLD)
        self.assertEqual(ret, None)

コード例 #40

 def _test_create_ofc_port(self, with_filter=False):
     t, n, p, f, none = self.get_random_params()
     self.ofc.create_ofc_tenant(self.ctx, t)
     self.ofc.create_ofc_network(self.ctx, t, n)
     self.assertFalse(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     get_portinfo = self._mock_get_portinfo(p)
     port = {'tenant_id': t, 'network_id': n}
     if with_filter:
         _filters = ['filter1', 'filter2']
         self.plugin.get_packet_filters_for_port.return_value = _filters
     self.ofc.create_ofc_port(self.ctx, p, port)
     self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_port', p))
     port = ndb.get_ofc_item(self.ctx.session, 'ofc_port', p)
     self.assertEqual(port.ofc_id, "ofc-" + p[:-4])
     get_portinfo.assert_called_once_with(mock.ANY, p)
     portval = self.ofc.driver.ofc_port_dict[port.ofc_id]
     if with_filter:
         self.assertEqual(_filters, portval['filters'])
     else:
         self.assertFalse('filters' in portval)

コード例 #41

ファイル: test_db.py プロジェクト: Brocade-OpenSource/OpenStack-DNRM-Neutron

    def testc_del_ofc_item(self):
        """test delete OFC item."""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
        ndb.del_ofc_item(self.session, 'ofc_tenant', q)

        tenant_none = ndb.get_ofc_item(self.session,
                                       'ofc_tenant', q)
        self.assertEqual(None, tenant_none)
        tenant_none = ndb.find_ofc_item(self.session,
                                        'ofc_tenant', o)
        self.assertEqual(None, tenant_none)

コード例 #42

ファイル: test_ofc_manager.py プロジェクト: AsherBond/quantum

    def test_router_route(self):
        t, r, _n = self.get_random_params()
        self.ofc.create_ofc_tenant(self.ctx, t)
        self.ofc.create_ofc_router(self.ctx, t, r)
        self.assertTrue(ndb.get_ofc_item(self.ctx.session, 'ofc_router', r))

        routes = [{'destination': '2.2.2.0/24', 'nexthop': '1.1.1.10'}]
        self.ofc.update_ofc_router_route(self.ctx, r, routes)
        self.assertEqual(len(self.ofc.driver.ofc_router_route_dict), 1)

        routes = [{'destination': '3.3.3.0/24', 'nexthop': '1.1.1.11'},
                  {'destination': '4.4.4.0/24', 'nexthop': '1.1.1.11'}]
        self.ofc.update_ofc_router_route(self.ctx, r, routes)
        self.assertEqual(len(self.ofc.driver.ofc_router_route_dict), 2)

        routes = [{'destination': '2.2.2.0/24', 'nexthop': '1.1.1.10'}]
        self.ofc.update_ofc_router_route(self.ctx, r, routes)
        self.assertEqual(len(self.ofc.driver.ofc_router_route_dict), 1)

        routes = []
        self.ofc.update_ofc_router_route(self.ctx, r, routes)
        self.assertEqual(len(self.ofc.driver.ofc_router_route_dict), 0)

コード例 #43

ファイル: test_db.py プロジェクト: nabilmaad/neutron

 def test_get_ofc_item_for_nonexisting_entry(self):
     self.assertIsNone(
         ndb.get_ofc_item(self.session, 'ofc_tenant', 'non-exist-id'))

コード例 #44

ファイル: test_db.py プロジェクト: CiscoSystems/neutron

 def test_get_ofc_item(self):
     o, q, n = self.get_ofc_item_random_params()
     ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
     tenant = ndb.get_ofc_item(self.session, 'ofc_tenant', q)
     self.assertEqual(tenant.ofc_id, o)
     self.assertEqual(tenant.neutron_id, q)

コード例 #45

ファイル: test_db.py プロジェクト: nabilmaad/neutron

 def test_get_ofc_item(self):
     o, q, n = self.get_ofc_item_random_params()
     ndb.add_ofc_item(self.session, 'ofc_tenant', q, o)
     tenant = ndb.get_ofc_item(self.session, 'ofc_tenant', q)
     self.assertEqual(tenant.ofc_id, o)
     self.assertEqual(tenant.quantum_id, q)

コード例 #46

ファイル: test_db.py プロジェクト: CiscoSystems/neutron

 def test_get_ofc_item_for_nonexisting_entry(self):
     self.assertIsNone(
         ndb.get_ofc_item(self.session, 'ofc_tenant', 'non-exist-id'))