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 项目： StackOps/quantum

 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

 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])

示例#4

 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))

示例#5

文件： test_ofc_manager.py 项目： StackOps/quantum

 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

文件： test_ofc_manager.py 项目： StackOps/quantum

 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])

示例#7

 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])

示例#8

文件： test_ofc_manager.py 项目： StackOps/quantum

 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])

示例#9

文件： test_db.py 项目： soheilhy/quantum

    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)

示例#10

文件： test_db.py 项目： AmirolAhmad/quantum

    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)

示例#11

文件： test_db.py 项目： sunguoqiang/quantum

    def testb_get_ofc_item(self):
        """test get OFC item"""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(nmodels.OFCTenant, o, q)
        tenant = ndb.get_ofc_item(nmodels.OFCTenant, o)
        self.assertEqual(tenant.id, o)
        self.assertEqual(tenant.quantum_id, q)

        tenant_none = ndb.get_ofc_item(nmodels.OFCTenant, n)
        self.assertEqual(None, tenant_none)

示例#12

文件： test_db.py 项目： FreescaleSemiconductor/quantum

    def testb_get_ofc_item(self):
        """test get OFC item"""
        o, q, n = self.get_ofc_item_random_params()
        ndb.add_ofc_item(nmodels.OFCTenant, o, q)
        tenant = ndb.get_ofc_item(nmodels.OFCTenant, o)
        self.assertEqual(tenant.id, o)
        self.assertEqual(tenant.quantum_id, q)

        tenant_none = ndb.get_ofc_item(nmodels.OFCTenant, n)
        self.assertEqual(None, tenant_none)

示例#13

文件： test_db.py 项目： soheilhy/quantum

    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)

示例#14

文件： test_db.py 项目： AmirolAhmad/quantum

    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)

示例#15

 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))

示例#16

文件： test_ofc_manager.py 项目： StackOps/quantum

 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))

示例#17

文件： test_ofc_manager.py 项目： StackOps/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)
     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 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))

示例#19

 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])

示例#20

文件： test_ofc_manager.py 项目： StackOps/quantum

 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])

示例#21

文件： test_ofc_manager.py 项目： StackOps/quantum

 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])

示例#22

 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])

示例#23

文件： test_db.py 项目： soheilhy/quantum

    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)

示例#24

文件： test_db.py 项目： rosstaylor/quantum

    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.assertEqual(None, tenant_none)

示例#25

文件： test_db.py 项目： AmirolAhmad/quantum

    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)

示例#26

文件： test_db.py 项目： FreescaleSemiconductor/quantum

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

        tenant_none = ndb.get_ofc_item(nmodels.OFCTenant, q)
        self.assertEqual(None, tenant_none)
        tenant_none = ndb.find_ofc_item(nmodels.OFCTenant, q)
        self.assertEqual(None, tenant_none)

示例#27

文件： test_db.py 项目： sunguoqiang/quantum

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

        tenant_none = ndb.get_ofc_item(nmodels.OFCTenant, q)
        self.assertEqual(None, tenant_none)
        tenant_none = ndb.find_ofc_item(nmodels.OFCTenant, q)
        self.assertEqual(None, tenant_none)

示例#28

文件： test_db.py 项目： rosstaylor/quantum

    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)

示例#29

    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)

示例#30

文件： test_db.py 项目： soheilhy/quantum

    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)

示例#31

文件： test_db.py 项目： AmirolAhmad/quantum

    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)