def test_allocate_tenant_segment(self): tunnel_ids = set() for x in moves.range(TUN_MIN, TUN_MAX + 1): segment = self.driver.allocate_tenant_segment(self.session) self.assertThat(segment[api.SEGMENTATION_ID], matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(segment[api.SEGMENTATION_ID], matchers.LessThan(TUN_MAX + 1)) tunnel_ids.add(segment[api.SEGMENTATION_ID]) segment = self.driver.allocate_tenant_segment(self.session) self.assertIsNone(segment) segment = {api.NETWORK_TYPE: self.TYPE, api.PHYSICAL_NETWORK: 'None', api.SEGMENTATION_ID: tunnel_ids.pop()} self.driver.release_segment(self.session, segment) segment = self.driver.allocate_tenant_segment(self.session) self.assertThat(segment[api.SEGMENTATION_ID], matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(segment[api.SEGMENTATION_ID], matchers.LessThan(TUN_MAX + 1)) tunnel_ids.add(segment[api.SEGMENTATION_ID]) for tunnel_id in tunnel_ids: segment[api.SEGMENTATION_ID] = tunnel_id self.driver.release_segment(self.session, segment)
def test_reserve_provider_segment(self): tunnel_ids = set() specs = {api.NETWORK_TYPE: self.TYPE, api.PHYSICAL_NETWORK: 'None', api.SEGMENTATION_ID: None} for x in moves.range(TUN_MIN, TUN_MAX + 1): segment = self.driver.reserve_provider_segment(self.session, specs) self.assertEqual(self.TYPE, segment[api.NETWORK_TYPE]) self.assertThat(segment[api.SEGMENTATION_ID], matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(segment[api.SEGMENTATION_ID], matchers.LessThan(TUN_MAX + 1)) tunnel_ids.add(segment[api.SEGMENTATION_ID]) with testtools.ExpectedException(exc.NoNetworkAvailable): segment = self.driver.reserve_provider_segment(self.session, specs) segment = {api.NETWORK_TYPE: self.TYPE, api.PHYSICAL_NETWORK: 'None', api.SEGMENTATION_ID: tunnel_ids.pop()} self.driver.release_segment(self.session, segment) segment = self.driver.reserve_provider_segment(self.session, specs) self.assertThat(segment[api.SEGMENTATION_ID], matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(segment[api.SEGMENTATION_ID], matchers.LessThan(TUN_MAX + 1)) tunnel_ids.add(segment[api.SEGMENTATION_ID]) for tunnel_id in tunnel_ids: segment[api.SEGMENTATION_ID] = tunnel_id self.driver.release_segment(self.session, segment)
def test_vlan_pool(self): vlan_ids = set() for x in moves.xrange(VLAN_MIN, VLAN_MAX + 1): (physical_network, seg_type, vlan_id, m_ip) = n1kv_db_v2.reserve_vlan(self.session, self.net_p) self.assertEqual(physical_network, PHYS_NET) self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1)) vlan_ids.add(vlan_id) self.assertRaises(n_exc.NoNetworkAvailable, n1kv_db_v2.reserve_vlan, self.session, self.net_p) n1kv_db_v2.release_vlan(self.session, PHYS_NET, vlan_ids.pop()) physical_network, seg_type, vlan_id, m_ip = (n1kv_db_v2.reserve_vlan( self.session, self.net_p)) self.assertEqual(physical_network, PHYS_NET) self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1)) vlan_ids.add(vlan_id) for vlan_id in vlan_ids: n1kv_db_v2.release_vlan(self.session, PHYS_NET, vlan_id)
def test_vxlan_pool(self): vxlan_ids = set() profile = n1kv_db_v2.create_network_profile(self.session, TEST_NETWORK_PROFILE_VXLAN) for x in xrange(VXLAN_MIN, VXLAN_MAX + 1): vxlan = n1kv_db_v2.reserve_vxlan(self.session, profile) vxlan_id = vxlan[2] self.assertThat(vxlan_id, matchers.GreaterThan(VXLAN_MIN - 1)) self.assertThat(vxlan_id, matchers.LessThan(VXLAN_MAX + 1)) vxlan_ids.add(vxlan_id) self.assertRaises(q_exc.NoNetworkAvailable, n1kv_db_v2.reserve_vxlan, self.session, profile) n1kv_db_v2.release_vxlan(self.session, vxlan_ids.pop(), VXLAN_RANGES) vxlan = n1kv_db_v2.reserve_vxlan(self.session, profile) vxlan_id = vxlan[2] self.assertThat(vxlan_id, matchers.GreaterThan(VXLAN_MIN - 1)) self.assertThat(vxlan_id, matchers.LessThan(VXLAN_MAX + 1)) vxlan_ids.add(vxlan_id) for vxlan_id in vxlan_ids: n1kv_db_v2.release_vxlan(self.session, vxlan_id, VXLAN_RANGES) n1kv_db_v2.delete_network_profile(self.session, profile.id)
def test_vlan_pool(self): vlan_ids = set() p = _create_test_network_profile_if_not_there(self.session) for x in xrange(VLAN_MIN, VLAN_MAX + 1): (physical_network, seg_type, vlan_id, m_ip) = n1kv_db_v2.reserve_vlan(self.session, p) self.assertEqual(physical_network, PHYS_NET) self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1)) vlan_ids.add(vlan_id) self.assertRaises(q_exc.NoNetworkAvailable, n1kv_db_v2.reserve_vlan, self.session, p) n1kv_db_v2.release_vlan(self.session, PHYS_NET, vlan_ids.pop(), VLAN_RANGES) physical_network, seg_type, vlan_id, m_ip = (n1kv_db_v2.reserve_vlan( self.session, p)) self.assertEqual(physical_network, PHYS_NET) self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1)) vlan_ids.add(vlan_id) for vlan_id in vlan_ids: n1kv_db_v2.release_vlan(self.session, PHYS_NET, vlan_id, VLAN_RANGES)
def test_random_name(self): name1 = self._runner.testRandomName() name2 = self._runner.testRandomName() self.assertIsInstance(name1, types.StringTypes) self.assertIsInstance(name2, types.StringTypes) self.assertThat(len(name1), matchers.GreaterThan(12)) self.assertThat(len(name2), matchers.GreaterThan(12)) self.assertThat(name1, matchers.NotEquals(name2))
def test_ui_hints(self): schema = self._test_simple_property('decoratedProperty', 'string') self.assertEqual('Title!', schema.get('title')) self.assertEqual('Description!', schema.get('description')) self.assertEqual('Help!', schema.get('helpText')) self.assertFalse(schema.get('visible')) self.assertThat(schema.get('formIndex'), matchers.GreaterThan(-1)) self.assertEqual('mySection', schema.get('formSection')) sections = self._class_schema.get('formSections') self.assertIsInstance(sections, dict) section = sections.get('mySection') self.assertIsInstance(section, dict) self.assertThat(section.get('index'), matchers.GreaterThan(-1)) self.assertEqual('Section Title', section.get('title'))
def test_multiple_servers(self): timeout = 0.5 if self.url.startswith("amqp:"): self.skipTest("QPID-6307") if self.url.startswith("kafka://"): self.skipTest("Kafka: needs to be fixed") timeout = 5 self.conf.set_override('consumer_group', 'test_multiple_servers', group='oslo_messaging_kafka') listener_a = self.useFixture( utils.NotificationFixture(self.conf, self.url, ['test-topic'])) listener_b = self.useFixture( utils.NotificationFixture(self.conf, self.url, ['test-topic'])) n = listener_a.notifier('pub') events_out = [('test-%s' % c, 'payload-%s' % c) for c in 'abcdefgh'] for event_type, payload in events_out: n.info({}, event_type, payload) events_in = [[(e[1], e[2]) for e in listener_a.get_events(timeout)], [(e[1], e[2]) for e in listener_b.get_events(timeout)]] self.assertThat(events_in, utils.IsValidDistributionOf(events_out)) for stream in events_in: self.assertThat(len(stream), matchers.GreaterThan(0))
def test_multiple_servers(self): if self.url.startswith("amqp:"): self.skipTest("QPID-6307") if self.url.startswith("zmq"): self.skipTest("ZeroMQ-PUB-SUB") if self.url.startswith("kafka"): self.skipTest("Kafka: Need to be fixed") listener_a = self.useFixture( utils.NotificationFixture(self.conf, self.url, ['test-topic'])) listener_b = self.useFixture( utils.NotificationFixture(self.conf, self.url, ['test-topic'])) n = listener_a.notifier('pub') events_out = [('test-%s' % c, 'payload-%s' % c) for c in 'abcdefgh'] for event_type, payload in events_out: n.info({}, event_type, payload) events_in = [[(e[1], e[2]) for e in listener_a.get_events()], [(e[1], e[2]) for e in listener_b.get_events()]] self.assertThat(events_in, utils.IsValidDistributionOf(events_out)) for stream in events_in: self.assertThat(len(stream), matchers.GreaterThan(0))
def test_create_get_list_accept_volume_transfer(self): # Create a volume first volume = self.create_volume() self.addCleanup(self._delete_volume, volume['id']) # Create a volume transfer resp, transfer = self.client.create_volume_transfer(volume['id']) self.assertEqual(202, resp.status) transfer_id = transfer['id'] auth_key = transfer['auth_key'] self.client.wait_for_volume_status(volume['id'], 'awaiting-transfer') # Get a volume transfer resp, body = self.client.get_volume_transfer(transfer_id) self.assertEqual(200, resp.status) self.assertEqual(volume['id'], body['volume_id']) # List volume transfers, the result should be greater than # or equal to 1 resp, body = self.client.list_volume_transfers() self.assertEqual(200, resp.status) self.assertThat(len(body), matchers.GreaterThan(0)) # Accept a volume transfer by alt_tenant resp, body = self.alt_client.accept_volume_transfer(transfer_id, auth_key) self.assertEqual(202, resp.status) self.alt_client.wait_for_volume_status(volume['id'], 'available')
def test_authenicate_refresh(self): self.client.authenticate() first_ts = self.client._token_timer self.client.authenticate() second_ts = self.client._token_timer self.assertThat(second_ts, matchers.GreaterThan(first_ts))
def _test_post(self, sample_messages): sample_doc = jsonutils.dumps(sample_messages) result = self.simulate_post(self.messages_path, self.project_id, body=sample_doc, headers=self.headers) self.assertEqual(self.srmock.status, falcon.HTTP_201) result_doc = jsonutils.loads(result[0]) msg_ids = self._get_msg_ids(self.srmock.headers_dict) self.assertEqual(len(msg_ids), len(sample_messages)) expected_resources = [six.text_type(self.messages_path + '/' + id) for id in msg_ids] self.assertEqual(expected_resources, result_doc['resources']) self.assertFalse(result_doc['partial']) self.assertEqual(len(msg_ids), len(sample_messages)) lookup = dict([(m['ttl'], m['body']) for m in sample_messages]) # Test GET on the message resource directly # NOTE(cpp-cabrera): force the passing of time to age a message timeutils_utcnow = 'marconi.openstack.common.timeutils.utcnow' now = timeutils.utcnow() + datetime.timedelta(seconds=10) with mock.patch(timeutils_utcnow) as mock_utcnow: mock_utcnow.return_value = now for msg_id in msg_ids: message_uri = self.messages_path + '/' + msg_id # Wrong project ID self.simulate_get(message_uri, '777777') self.assertEqual(self.srmock.status, falcon.HTTP_404) # Correct project ID result = self.simulate_get(message_uri, self.project_id) self.assertEqual(self.srmock.status, falcon.HTTP_200) self.assertEqual(self.srmock.headers_dict['Content-Location'], message_uri) # Check message properties message = jsonutils.loads(result[0]) self.assertEqual(message['href'], message_uri) self.assertEqual(message['body'], lookup[message['ttl']]) # no negative age # NOTE(cpp-cabrera): testtools lacks GreaterThanEqual on py26 self.assertThat(message['age'], matchers.GreaterThan(-1)) # Test bulk GET query_string = 'ids=' + ','.join(msg_ids) result = self.simulate_get(self.messages_path, self.project_id, query_string=query_string) self.assertEqual(self.srmock.status, falcon.HTTP_200) result_doc = jsonutils.loads(result[0]) expected_ttls = set(m['ttl'] for m in sample_messages) actual_ttls = set(m['ttl'] for m in result_doc) self.assertFalse(expected_ttls - actual_ttls)
def test_pep8(self): # NOTE(jecarey): Add tests marked as off_by_default to enable testing turn_on = set(['H106']) if self.options.select: turn_on.update(self.options.select) self.options.select = tuple(turn_on) report = pep8.BaseReport(self.options) checker = pep8.Checker(filename=self.filename, lines=self.lines, options=self.options, report=report) checker.check_all() self.addDetail('doctest', content.text_content(self.raw)) if self.code == 'Okay': self.assertThat( len(report.counters), matchers.Not( matchers.GreaterThan(len(self.options.benchmark_keys))), "incorrectly found %s" % ', '.join([ key for key in report.counters if key not in self.options.benchmark_keys ])) else: self.addDetail( 'reason', content.text_content("Failed to trigger rule %s" % self.code)) self.assertIn(self.code, report.counters)
def test_create_get_list_accept_volume_transfer(self): # Create a volume first volume = self.create_volume() self.addCleanup(self.delete_volume, self.adm_client, volume['id']) # Create a volume transfer transfer = self.client.create_volume_transfer( volume_id=volume['id'])['transfer'] transfer_id = transfer['id'] auth_key = transfer['auth_key'] waiters.wait_for_volume_status(self.client, volume['id'], 'awaiting-transfer') # Get a volume transfer body = self.client.show_volume_transfer(transfer_id)['transfer'] self.assertEqual(volume['id'], body['volume_id']) # List volume transfers, the result should be greater than # or equal to 1 body = self.client.list_volume_transfers()['transfers'] self.assertThat(len(body), matchers.GreaterThan(0)) # Accept a volume transfer by alt_tenant body = self.alt_client.accept_volume_transfer( transfer_id, auth_key=auth_key)['transfer'] waiters.wait_for_volume_status(self.alt_client, volume['id'], 'available')
def test_calculate_backoff(self): sec = utils.calculate_backoff(0, 10, 2, 0) self.assertEqual(sec, 0) sec = utils.calculate_backoff(9, 10, 2, 0) self.assertEqual(sec, 1.8) sec = utils.calculate_backoff(4, 10, 2, 0) self.assertEqual(sec, 0.8) sec = utils.calculate_backoff(4, 10, 2, 1) if sec != 0.8: self.assertThat(sec, matchers.GreaterThan(0.8)) self.assertThat(sec, matchers.LessThan(1.8)) self.assertRaises(ValueError, utils.calculate_backoff, 0, 10, -2, -1) self.assertRaises(ValueError, utils.calculate_backoff, 0, 10, -2, 0) self.assertRaises(ValueError, utils.calculate_backoff, 0, 10, 2, -1) self.assertRaises(ValueError, utils.calculate_backoff, -2, -10, 2, 0) self.assertRaises(ValueError, utils.calculate_backoff, 2, -10, 2, 0) self.assertRaises(ValueError, utils.calculate_backoff, -2, 10, 2, 0) self.assertRaises(ValueError, utils.calculate_backoff, -1, 10, 2, 0) self.assertRaises(ValueError, utils.calculate_backoff, 10, 10, 2, 0) self.assertRaises(ValueError, utils.calculate_backoff, 11, 10, 2, 0)
def test_allocate_tenant_segment(self): for __ in range(RT_NN_MIN, RT_NN_MAX + 1): segment = self.driver.allocate_tenant_segment(self.context) alloc = self._get_allocation(self.session, segment) self.assertTrue(alloc.allocated) rt_nn = segment[api.SEGMENTATION_ID] self.assertThat(rt_nn, matchers.GreaterThan(RT_NN_MIN - 1)) self.assertThat(rt_nn, matchers.LessThan(RT_NN_MAX + 1))
def test_parse_event(self): event = self._load_event('event_1') tenant_id, timestamp, event_type, payload = utils.parse_events_message(event) self.assertEqual('de98fbff448f4f278a56e9929db70b03', tenant_id) self.assertEqual('2017-06-01 09:15:11.494606', timestamp) self.assertEqual('compute.instance.create.start', event_type) self.assertIsNotNone(payload) self.assertThat(len(payload), matchers.GreaterThan(0))
def test_object_mutate(self): begin = datetime.datetime.utcnow() plan = objects.registry.Plan() self.assertIsNotNone(plan) plan.uuid = str(uuid.uuid4()) plan.create(self.ctx) self.assertIsNotNone(plan.id) self.assertThat(plan.created_at, matchers.GreaterThan(begin)) self.assertIsNone(plan.updated_at) next_time = datetime.datetime.utcnow() plan.save(self.ctx) self.assertThat(next_time, matchers.GreaterThan(plan.created_at))
def test_object_mutate(self): begin = datetime.datetime.utcnow() component = objects.registry.Component() self.assertIsNotNone(component) component.uuid = str(uuid.uuid4()) component.plan_id = 1 component.create(self.ctx) self.assertIsNotNone(component.id) self.assertThat(component.created_at, matchers.GreaterThan(begin)) self.assertIsNone(component.updated_at) next_time = datetime.datetime.utcnow() component.save(self.ctx) self.assertThat(next_time, matchers.GreaterThan(component.created_at))
def test_allocate_tenant_segment(self): for __ in range(VLAN_MIN, VLAN_MAX + 1): segment = self.driver.allocate_tenant_segment(self.session) alloc = self._get_allocation(self.session, segment) self.assertTrue(alloc.allocated) vlan_id = segment[api.SEGMENTATION_ID] self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1)) self.assertEqual(TENANT_NET, segment[api.PHYSICAL_NETWORK])
def test_reserve_provider_segment_without_segmentation_id(self): segment = {api.NETWORK_TYPE: p_const.TYPE_VLAN, api.PHYSICAL_NETWORK: TENANT_NET} observed = self.driver.reserve_provider_segment(self.context, segment) alloc = self._get_allocation(self.context, observed) self.assertTrue(alloc.allocated) vlan_id = observed[api.SEGMENTATION_ID] self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1))
def test_reserve_provider_segment_without_physical_network(self): segment = {api.NETWORK_TYPE: p_const.TYPE_VLAN} observed = self.driver.reserve_provider_segment(self.session, segment) alloc = self._get_allocation(self.session, observed) self.assertTrue(alloc.allocated) vlan_id = observed[api.SEGMENTATION_ID] self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1)) self.assertEqual(TENANT_NET, observed[api.PHYSICAL_NETWORK])
def assertGreater(self, first, second, msg=None): """Python < v2.7 compatibility. Assert 'first' > 'second'.""" try: f = super(TestCase, self).assertGreater except AttributeError: self.assertThat(first, matchers.GreaterThan(second), message=msg or '') else: f(first, second, msg=msg)
def test_tunnel_pool(self): tunnel_ids = set() for x in xrange(TUN_MIN, TUN_MAX + 1): tunnel_id = ovs_db_v2.reserve_tunnel(self.session) self.assertThat(tunnel_id, matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(tunnel_id, matchers.LessThan(TUN_MAX + 1)) tunnel_ids.add(tunnel_id) with testtools.ExpectedException(n_exc.NoNetworkAvailable): tunnel_id = ovs_db_v2.reserve_tunnel(self.session) ovs_db_v2.release_tunnel(self.session, tunnel_ids.pop(), TUNNEL_RANGES) tunnel_id = ovs_db_v2.reserve_tunnel(self.session) self.assertThat(tunnel_id, matchers.GreaterThan(TUN_MIN - 1)) self.assertThat(tunnel_id, matchers.LessThan(TUN_MAX + 1)) tunnel_ids.add(tunnel_id) for tunnel_id in tunnel_ids: ovs_db_v2.release_tunnel(self.session, tunnel_id, TUNNEL_RANGES)
def test_parse_event(self): event = self._load_event('event_1') project_id, timestamp, event_type, payload, dimensions = utils.parse_events_message(event) self.assertEqual('de98fbff448f4f278a56e9929db70b03', project_id) self.assertEqual('2017-06-01 09:15:11.494606', timestamp) self.assertEqual('compute.instance.create.start', event_type) self.assertEqual('compute', dimensions['service']) self.assertEqual('notification.sample', dimensions['topic']) self.assertEqual('nova-compute:compute', dimensions['hostname']) self.assertIsNotNone(payload) self.assertThat(len(payload), matchers.GreaterThan(0))
def test_create_l3_segments(self): rids = set() for x in moves.range(VXLAN_MIN, VXLAN_MAX + 1): rid = str(uuid.uuid1()) segment = self.driver.create_l3_segments(self.context, rid) self.assertThat(segment, matchers.GreaterThan(VXLAN_MIN - 1)) self.assertThat(segment, matchers.LessThan(VXLAN_MAX + 1)) rids.add(rid) self.assertRaises(h_exc.NoTunnelIdAvailable, self.driver.create_l3_segments, self.context, str(uuid.uuid1())) rid = rids.pop() self.driver.release_segment(self.context.session, rid) segment = self.driver.create_l3_segments(self.context, rid) self.assertThat(segment, matchers.GreaterThan(VXLAN_MIN - 1)) self.assertThat(segment, matchers.LessThan(VXLAN_MAX + 1)) rids.add(rid) for rid in rids: self.driver.release_segment(self.context.session, rid)
def test_vxlan_pool(self): vxlan_ids = set() for x in moves.xrange(VXLAN_MIN, VXLAN_MAX + 1): vxlan = n1kv_db_v2.reserve_vxlan(self.session, self.net_p) vxlan_id = vxlan[2] self.assertThat(vxlan_id, matchers.GreaterThan(VXLAN_MIN - 1)) self.assertThat(vxlan_id, matchers.LessThan(VXLAN_MAX + 1)) vxlan_ids.add(vxlan_id) self.assertRaises(n_exc.NoNetworkAvailable, n1kv_db_v2.reserve_vxlan, self.session, self.net_p) n1kv_db_v2.release_vxlan(self.session, vxlan_ids.pop()) vxlan = n1kv_db_v2.reserve_vxlan(self.session, self.net_p) vxlan_id = vxlan[2] self.assertThat(vxlan_id, matchers.GreaterThan(VXLAN_MIN - 1)) self.assertThat(vxlan_id, matchers.LessThan(VXLAN_MAX + 1)) vxlan_ids.add(vxlan_id) for vxlan_id in vxlan_ids: n1kv_db_v2.release_vxlan(self.session, vxlan_id) n1kv_db_v2.delete_network_profile(self.session, self.net_p.id)
def test_server_in_group(self): group = self.useFixture(RpcServerGroupFixture(self.url)) client = group.client() data = [c for c in 'abcdefghijklmn'] for i in data: client.append(text=i) for s in group.servers: self.assertThat(len(s.endpoint.sval), matchers.GreaterThan(0)) actual = [[c for c in s.endpoint.sval] for s in group.servers] self.assertThat(actual, IsValidDistributionOf(data))
def test_periodic_tasks_idle_calculation(self): class Manager(manager.Manager): @manager.periodic_task(spacing=10) def bar(self): return 'bar' m = Manager() m.periodic_tasks(None) time.sleep(0.1) idle = m.periodic_tasks(None) self.assertThat(idle, matchers.GreaterThan(9.7)) self.assertThat(idle, matchers.LessThan(9.9))
def test_sync_with_allocated_false(self): vlan_ids = set() for x in xrange(VLAN_MIN, VLAN_MAX + 1): physical_network, vlan_id = ovs_db_v2.reserve_vlan(self.session) self.assertEqual(physical_network, PHYS_NET) self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1)) self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1)) vlan_ids.add(vlan_id) ovs_db_v2.release_vlan(self.session, PHYS_NET, vlan_ids.pop(), VLAN_RANGES) ovs_db_v2.sync_vlan_allocations({})