"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "keystone/tests/unit/test_v3_catalog.py" between
keystone-16.0.1.tar.gz and keystone-17.0.0.tar.gz

About: OpenStack Keystone (Core Service: Identity) provides an authentication and authorization service for other OpenStack services. Provides a catalog of endpoints for all OpenStack services.
The "Ussuri" series (latest release).

test_v3_catalog.py  (keystone-16.0.1):test_v3_catalog.py  (keystone-17.0.0)
skipping to change at line 18 skipping to change at line 18
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import copy import copy
import uuid import uuid
from six.moves import http_client import http.client
from testtools import matchers from testtools import matchers
from keystone.common import provider_api from keystone.common import provider_api
from keystone.tests import unit from keystone.tests import unit
from keystone.tests.unit import default_fixtures from keystone.tests.unit import default_fixtures
from keystone.tests.unit.ksfixtures import database from keystone.tests.unit.ksfixtures import database
from keystone.tests.unit import test_v3 from keystone.tests.unit import test_v3
PROVIDERS = provider_api.ProviderAPIs PROVIDERS = provider_api.ProviderAPIs
skipping to change at line 41 skipping to change at line 41
# region crud tests # region crud tests
def test_create_region_with_id(self): def test_create_region_with_id(self):
"""Call ``PUT /regions/{region_id}`` w/o an ID in the request body.""" """Call ``PUT /regions/{region_id}`` w/o an ID in the request body."""
ref = unit.new_region_ref() ref = unit.new_region_ref()
region_id = ref.pop('id') region_id = ref.pop('id')
r = self.put( r = self.put(
'/regions/%s' % region_id, '/regions/%s' % region_id,
body={'region': ref}, body={'region': ref},
expected_status=http_client.CREATED) expected_status=http.client.CREATED)
self.assertValidRegionResponse(r, ref) self.assertValidRegionResponse(r, ref)
# Double-check that the region ID was kept as-is and not # Double-check that the region ID was kept as-is and not
# populated with a UUID, as is the case with POST /v3/regions # populated with a UUID, as is the case with POST /v3/regions
self.assertEqual(region_id, r.json['region']['id']) self.assertEqual(region_id, r.json['region']['id'])
def test_create_region_with_matching_ids(self): def test_create_region_with_matching_ids(self):
"""Call ``PUT /regions/{region_id}`` with an ID in the request body.""" """Call ``PUT /regions/{region_id}`` with an ID in the request body."""
ref = unit.new_region_ref() ref = unit.new_region_ref()
region_id = ref['id'] region_id = ref['id']
r = self.put( r = self.put(
'/regions/%s' % region_id, '/regions/%s' % region_id,
body={'region': ref}, body={'region': ref},
expected_status=http_client.CREATED) expected_status=http.client.CREATED)
self.assertValidRegionResponse(r, ref) self.assertValidRegionResponse(r, ref)
# Double-check that the region ID was kept as-is and not # Double-check that the region ID was kept as-is and not
# populated with a UUID, as is the case with POST /v3/regions # populated with a UUID, as is the case with POST /v3/regions
self.assertEqual(region_id, r.json['region']['id']) self.assertEqual(region_id, r.json['region']['id'])
def test_create_region_with_duplicate_id(self): def test_create_region_with_duplicate_id(self):
"""Call ``PUT /regions/{region_id}``.""" """Call ``PUT /regions/{region_id}``."""
ref = unit.new_region_ref() ref = unit.new_region_ref()
region_id = ref['id'] region_id = ref['id']
self.put( self.put(
'/regions/%s' % region_id, '/regions/%s' % region_id,
body={'region': ref}, expected_status=http_client.CREATED) body={'region': ref}, expected_status=http.client.CREATED)
# Create region again with duplicate id # Create region again with duplicate id
self.put( self.put(
'/regions/%s' % region_id, '/regions/%s' % region_id,
body={'region': ref}, expected_status=http_client.CONFLICT) body={'region': ref}, expected_status=http.client.CONFLICT)
def test_create_region(self): def test_create_region(self):
"""Call ``POST /regions`` with an ID in the request body.""" """Call ``POST /regions`` with an ID in the request body."""
# the ref will have an ID defined on it # the ref will have an ID defined on it
ref = unit.new_region_ref() ref = unit.new_region_ref()
r = self.post( r = self.post(
'/regions', '/regions',
body={'region': ref}) body={'region': ref})
self.assertValidRegionResponse(r, ref) self.assertValidRegionResponse(r, ref)
skipping to change at line 165 skipping to change at line 165
def test_create_region_with_conflicting_ids(self): def test_create_region_with_conflicting_ids(self):
"""Call ``PUT /regions/{region_id}`` with conflicting region IDs.""" """Call ``PUT /regions/{region_id}`` with conflicting region IDs."""
# the region ref is created with an ID # the region ref is created with an ID
ref = unit.new_region_ref() ref = unit.new_region_ref()
# but instead of using that ID, make up a new, conflicting one # but instead of using that ID, make up a new, conflicting one
self.put( self.put(
'/regions/%s' % uuid.uuid4().hex, '/regions/%s' % uuid.uuid4().hex,
body={'region': ref}, body={'region': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_list_head_regions(self): def test_list_head_regions(self):
"""Call ``GET & HEAD /regions``.""" """Call ``GET & HEAD /regions``."""
resource_url = '/regions' resource_url = '/regions'
r = self.get(resource_url) r = self.get(resource_url)
self.assertValidRegionListResponse(r, ref=self.region) self.assertValidRegionListResponse(r, ref=self.region)
self.head(resource_url, expected_status=http_client.OK) self.head(resource_url, expected_status=http.client.OK)
def _create_region_with_parent_id(self, parent_id=None): def _create_region_with_parent_id(self, parent_id=None):
ref = unit.new_region_ref(parent_region_id=parent_id) ref = unit.new_region_ref(parent_region_id=parent_id)
return self.post( return self.post(
'/regions', '/regions',
body={'region': ref}) body={'region': ref})
def test_list_regions_filtered_by_parent_region_id(self): def test_list_regions_filtered_by_parent_region_id(self):
"""Call ``GET /regions?parent_region_id={parent_region_id}``.""" """Call ``GET /regions?parent_region_id={parent_region_id}``."""
new_region = self._create_region_with_parent_id() new_region = self._create_region_with_parent_id()
skipping to change at line 199 skipping to change at line 199
for region in r.result['regions']: for region in r.result['regions']:
self.assertEqual(parent_id, region['parent_region_id']) self.assertEqual(parent_id, region['parent_region_id'])
def test_get_head_region(self): def test_get_head_region(self):
"""Call ``GET & HEAD /regions/{region_id}``.""" """Call ``GET & HEAD /regions/{region_id}``."""
resource_url = '/regions/%(region_id)s' % { resource_url = '/regions/%(region_id)s' % {
'region_id': self.region_id} 'region_id': self.region_id}
r = self.get(resource_url) r = self.get(resource_url)
self.assertValidRegionResponse(r, self.region) self.assertValidRegionResponse(r, self.region)
self.head(resource_url, expected_status=http_client.OK) self.head(resource_url, expected_status=http.client.OK)
def test_update_region(self): def test_update_region(self):
"""Call ``PATCH /regions/{region_id}``.""" """Call ``PATCH /regions/{region_id}``."""
region = unit.new_region_ref() region = unit.new_region_ref()
del region['id'] del region['id']
r = self.patch('/regions/%(region_id)s' % { r = self.patch('/regions/%(region_id)s' % {
'region_id': self.region_id}, 'region_id': self.region_id},
body={'region': region}) body={'region': region})
self.assertValidRegionResponse(r, region) self.assertValidRegionResponse(r, region)
skipping to change at line 304 skipping to change at line 304
r = self.post( r = self.post(
'/services', '/services',
body={'service': ref}) body={'service': ref})
self.assertValidServiceResponse(r, ref) self.assertValidServiceResponse(r, ref)
self.assertIs(True, r.result['service']['enabled']) self.assertIs(True, r.result['service']['enabled'])
def test_create_service_enabled_str_true(self): def test_create_service_enabled_str_true(self):
"""Call ``POST /services``.""" """Call ``POST /services``."""
ref = unit.new_service_ref(enabled='True') ref = unit.new_service_ref(enabled='True')
self.post('/services', body={'service': ref}, self.post('/services', body={'service': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_create_service_enabled_str_false(self): def test_create_service_enabled_str_false(self):
"""Call ``POST /services``.""" """Call ``POST /services``."""
ref = unit.new_service_ref(enabled='False') ref = unit.new_service_ref(enabled='False')
self.post('/services', body={'service': ref}, self.post('/services', body={'service': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_create_service_enabled_str_random(self): def test_create_service_enabled_str_random(self):
"""Call ``POST /services``.""" """Call ``POST /services``."""
ref = unit.new_service_ref(enabled='puppies') ref = unit.new_service_ref(enabled='puppies')
self.post('/services', body={'service': ref}, self.post('/services', body={'service': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_list_head_services(self): def test_list_head_services(self):
"""Call ``GET & HEAD /services``.""" """Call ``GET & HEAD /services``."""
resource_url = '/services' resource_url = '/services'
r = self.get(resource_url) r = self.get(resource_url)
self.assertValidServiceListResponse(r, ref=self.service) self.assertValidServiceListResponse(r, ref=self.service)
self.head(resource_url, expected_status=http_client.OK) self.head(resource_url, expected_status=http.client.OK)
def _create_random_service(self): def _create_random_service(self):
ref = unit.new_service_ref() ref = unit.new_service_ref()
response = self.post( response = self.post(
'/services', '/services',
body={'service': ref}) body={'service': ref})
return response.json['service'] return response.json['service']
def test_filter_list_services_by_type(self): def test_filter_list_services_by_type(self):
"""Call ``GET /services?type=<some type>``.""" """Call ``GET /services?type=<some type>``."""
skipping to change at line 379 skipping to change at line 379
self.config_fixture.config(list_limit=1) self.config_fixture.config(list_limit=1)
self.test_filter_list_services_by_name() self.test_filter_list_services_by_name()
def test_get_head_service(self): def test_get_head_service(self):
"""Call ``GET & HEAD /services/{service_id}``.""" """Call ``GET & HEAD /services/{service_id}``."""
resource_url = '/services/%(service_id)s' % { resource_url = '/services/%(service_id)s' % {
'service_id': self.service_id} 'service_id': self.service_id}
r = self.get(resource_url) r = self.get(resource_url)
self.assertValidServiceResponse(r, self.service) self.assertValidServiceResponse(r, self.service)
self.head(resource_url, expected_status=http_client.OK) self.head(resource_url, expected_status=http.client.OK)
def test_update_service(self): def test_update_service(self):
"""Call ``PATCH /services/{service_id}``.""" """Call ``PATCH /services/{service_id}``."""
service = unit.new_service_ref() service = unit.new_service_ref()
del service['id'] del service['id']
r = self.patch('/services/%(service_id)s' % { r = self.patch('/services/%(service_id)s' % {
'service_id': self.service_id}, 'service_id': self.service_id},
body={'service': service}) body={'service': service})
self.assertValidServiceResponse(r, service) self.assertValidServiceResponse(r, service)
skipping to change at line 402 skipping to change at line 402
self.delete('/services/%(service_id)s' % { self.delete('/services/%(service_id)s' % {
'service_id': self.service_id}) 'service_id': self.service_id})
# endpoint crud tests # endpoint crud tests
def test_list_head_endpoints(self): def test_list_head_endpoints(self):
"""Call ``GET & HEAD /endpoints``.""" """Call ``GET & HEAD /endpoints``."""
resource_url = '/endpoints' resource_url = '/endpoints'
r = self.get(resource_url) r = self.get(resource_url)
self.assertValidEndpointListResponse(r, ref=self.endpoint) self.assertValidEndpointListResponse(r, ref=self.endpoint)
self.head(resource_url, expected_status=http_client.OK) self.head(resource_url, expected_status=http.client.OK)
def _create_random_endpoint(self, interface='public', def _create_random_endpoint(self, interface='public',
parent_region_id=None): parent_region_id=None):
region = self._create_region_with_parent_id( region = self._create_region_with_parent_id(
parent_id=parent_region_id) parent_id=parent_region_id)
service = self._create_random_service() service = self._create_random_service()
ref = unit.new_endpoint_ref( ref = unit.new_endpoint_ref(
service_id=service['id'], service_id=service['id'],
interface=interface, interface=interface,
region_id=region.result['region']['id']) region_id=region.result['region']['id'])
skipping to change at line 565 skipping to change at line 565
r = self.post('/endpoints', body={'endpoint': ref}) r = self.post('/endpoints', body={'endpoint': ref})
self.assertValidEndpointResponse(r, ref) self.assertValidEndpointResponse(r, ref)
def test_create_endpoint_enabled_str_true(self): def test_create_endpoint_enabled_str_true(self):
"""Call ``POST /endpoints`` with enabled: 'True'.""" """Call ``POST /endpoints`` with enabled: 'True'."""
ref = unit.new_endpoint_ref(service_id=self.service_id, ref = unit.new_endpoint_ref(service_id=self.service_id,
interface='public', interface='public',
region_id=self.region_id, region_id=self.region_id,
enabled='True') enabled='True')
self.post('/endpoints', body={'endpoint': ref}, self.post('/endpoints', body={'endpoint': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_create_endpoint_enabled_str_false(self): def test_create_endpoint_enabled_str_false(self):
"""Call ``POST /endpoints`` with enabled: 'False'.""" """Call ``POST /endpoints`` with enabled: 'False'."""
ref = unit.new_endpoint_ref(service_id=self.service_id, ref = unit.new_endpoint_ref(service_id=self.service_id,
interface='public', interface='public',
region_id=self.region_id, region_id=self.region_id,
enabled='False') enabled='False')
self.post('/endpoints', body={'endpoint': ref}, self.post('/endpoints', body={'endpoint': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_create_endpoint_enabled_str_random(self): def test_create_endpoint_enabled_str_random(self):
"""Call ``POST /endpoints`` with enabled: 'puppies'.""" """Call ``POST /endpoints`` with enabled: 'puppies'."""
ref = unit.new_endpoint_ref(service_id=self.service_id, ref = unit.new_endpoint_ref(service_id=self.service_id,
interface='public', interface='public',
region_id=self.region_id, region_id=self.region_id,
enabled='puppies') enabled='puppies')
self.post('/endpoints', body={'endpoint': ref}, self.post('/endpoints', body={'endpoint': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_create_endpoint_with_invalid_region_id(self): def test_create_endpoint_with_invalid_region_id(self):
"""Call ``POST /endpoints``.""" """Call ``POST /endpoints``."""
ref = unit.new_endpoint_ref(service_id=self.service_id) ref = unit.new_endpoint_ref(service_id=self.service_id)
self.post('/endpoints', body={'endpoint': ref}, self.post('/endpoints', body={'endpoint': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_create_endpoint_with_region(self): def test_create_endpoint_with_region(self):
"""EndpointV3 creates the region before creating the endpoint. """EndpointV3 creates the region before creating the endpoint.
This occurs when endpoint is provided with 'region' and no 'region_id'. This occurs when endpoint is provided with 'region' and no 'region_id'.
""" """
ref = unit.new_endpoint_ref_with_region(service_id=self.service_id, ref = unit.new_endpoint_ref_with_region(service_id=self.service_id,
region=uuid.uuid4().hex) region=uuid.uuid4().hex)
self.post('/endpoints', body={'endpoint': ref}) self.post('/endpoints', body={'endpoint': ref})
# Make sure the region is created # Make sure the region is created
skipping to change at line 612 skipping to change at line 612
def test_create_endpoint_with_no_region(self): def test_create_endpoint_with_no_region(self):
"""EndpointV3 allows to creates the endpoint without region.""" """EndpointV3 allows to creates the endpoint without region."""
ref = unit.new_endpoint_ref(service_id=self.service_id, region_id=None) ref = unit.new_endpoint_ref(service_id=self.service_id, region_id=None)
del ref['region_id'] # cannot just be None, it needs to not exist del ref['region_id'] # cannot just be None, it needs to not exist
self.post('/endpoints', body={'endpoint': ref}) self.post('/endpoints', body={'endpoint': ref})
def test_create_endpoint_with_empty_url(self): def test_create_endpoint_with_empty_url(self):
"""Call ``POST /endpoints``.""" """Call ``POST /endpoints``."""
ref = unit.new_endpoint_ref(service_id=self.service_id, url='') ref = unit.new_endpoint_ref(service_id=self.service_id, url='')
self.post('/endpoints', body={'endpoint': ref}, self.post('/endpoints', body={'endpoint': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_get_head_endpoint(self): def test_get_head_endpoint(self):
"""Call ``GET & HEAD /endpoints/{endpoint_id}``.""" """Call ``GET & HEAD /endpoints/{endpoint_id}``."""
resource_url = '/endpoints/%(endpoint_id)s' % { resource_url = '/endpoints/%(endpoint_id)s' % {
'endpoint_id': self.endpoint_id} 'endpoint_id': self.endpoint_id}
r = self.get(resource_url) r = self.get(resource_url)
self.assertValidEndpointResponse(r, self.endpoint) self.assertValidEndpointResponse(r, self.endpoint)
self.head(resource_url, expected_status=http_client.OK) self.head(resource_url, expected_status=http.client.OK)
def test_update_endpoint(self): def test_update_endpoint(self):
"""Call ``PATCH /endpoints/{endpoint_id}``.""" """Call ``PATCH /endpoints/{endpoint_id}``."""
ref = unit.new_endpoint_ref(service_id=self.service_id, ref = unit.new_endpoint_ref(service_id=self.service_id,
interface='public', interface='public',
region_id=self.region_id) region_id=self.region_id)
del ref['id'] del ref['id']
r = self.patch( r = self.patch(
'/endpoints/%(endpoint_id)s' % { '/endpoints/%(endpoint_id)s' % {
'endpoint_id': self.endpoint_id}, 'endpoint_id': self.endpoint_id},
skipping to change at line 659 skipping to change at line 659
exp_endpoint = copy.copy(self.endpoint) exp_endpoint = copy.copy(self.endpoint)
exp_endpoint['enabled'] = False exp_endpoint['enabled'] = False
self.assertValidEndpointResponse(r, exp_endpoint) self.assertValidEndpointResponse(r, exp_endpoint)
def test_update_endpoint_enabled_str_true(self): def test_update_endpoint_enabled_str_true(self):
"""Call ``PATCH /endpoints/{endpoint_id}`` with enabled: 'True'.""" """Call ``PATCH /endpoints/{endpoint_id}`` with enabled: 'True'."""
self.patch( self.patch(
'/endpoints/%(endpoint_id)s' % { '/endpoints/%(endpoint_id)s' % {
'endpoint_id': self.endpoint_id}, 'endpoint_id': self.endpoint_id},
body={'endpoint': {'enabled': 'True'}}, body={'endpoint': {'enabled': 'True'}},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_update_endpoint_enabled_str_false(self): def test_update_endpoint_enabled_str_false(self):
"""Call ``PATCH /endpoints/{endpoint_id}`` with enabled: 'False'.""" """Call ``PATCH /endpoints/{endpoint_id}`` with enabled: 'False'."""
self.patch( self.patch(
'/endpoints/%(endpoint_id)s' % { '/endpoints/%(endpoint_id)s' % {
'endpoint_id': self.endpoint_id}, 'endpoint_id': self.endpoint_id},
body={'endpoint': {'enabled': 'False'}}, body={'endpoint': {'enabled': 'False'}},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_update_endpoint_enabled_str_random(self): def test_update_endpoint_enabled_str_random(self):
"""Call ``PATCH /endpoints/{endpoint_id}`` with enabled: 'kitties'.""" """Call ``PATCH /endpoints/{endpoint_id}`` with enabled: 'kitties'."""
self.patch( self.patch(
'/endpoints/%(endpoint_id)s' % { '/endpoints/%(endpoint_id)s' % {
'endpoint_id': self.endpoint_id}, 'endpoint_id': self.endpoint_id},
body={'endpoint': {'enabled': 'kitties'}}, body={'endpoint': {'enabled': 'kitties'}},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
def test_delete_endpoint(self): def test_delete_endpoint(self):
"""Call ``DELETE /endpoints/{endpoint_id}``.""" """Call ``DELETE /endpoints/{endpoint_id}``."""
self.delete( self.delete(
'/endpoints/%(endpoint_id)s' % { '/endpoints/%(endpoint_id)s' % {
'endpoint_id': self.endpoint_id}) 'endpoint_id': self.endpoint_id})
def test_deleting_endpoint_with_space_in_url(self): def test_deleting_endpoint_with_space_in_url(self):
# add a space to all urls (intentional "i d" to test bug) # add a space to all urls (intentional "i d" to test bug)
url_with_space = "http://127.0.0.1:8774 /v1.1/\$(tenant_i d)s" url_with_space = "http://127.0.0.1:8774 /v1.1/\$(tenant_i d)s"
skipping to change at line 703 skipping to change at line 703
url=url_with_space) url=url_with_space)
# add the endpoint to the database # add the endpoint to the database
PROVIDERS.catalog_api.create_endpoint(ref['id'], ref) PROVIDERS.catalog_api.create_endpoint(ref['id'], ref)
# delete the endpoint # delete the endpoint
self.delete('/endpoints/%s' % ref['id']) self.delete('/endpoints/%s' % ref['id'])
# make sure it's deleted (GET should return Not Found) # make sure it's deleted (GET should return Not Found)
self.get('/endpoints/%s' % ref['id'], self.get('/endpoints/%s' % ref['id'],
expected_status=http_client.NOT_FOUND) expected_status=http.client.NOT_FOUND)
def test_endpoint_create_with_valid_url(self): def test_endpoint_create_with_valid_url(self):
"""Create endpoint with valid url should be tested,too.""" """Create endpoint with valid url should be tested,too."""
# list one valid url is enough, no need to list too much # list one valid url is enough, no need to list too much
valid_url = 'http://127.0.0.1:8774/v1.1/$(project_id)s' valid_url = 'http://127.0.0.1:8774/v1.1/$(project_id)s'
ref = unit.new_endpoint_ref(self.service_id, ref = unit.new_endpoint_ref(self.service_id,
interface='public', interface='public',
region_id=self.region_id, region_id=self.region_id,
url=valid_url) url=valid_url)
skipping to change at line 748 skipping to change at line 748
# admin_url is a string not an int # admin_url is a string not an int
'http://127.0.0.1:8774/v1.1/$(admin_url)d', 'http://127.0.0.1:8774/v1.1/$(admin_url)d',
] ]
ref = unit.new_endpoint_ref(self.service_id) ref = unit.new_endpoint_ref(self.service_id)
for invalid_url in invalid_urls: for invalid_url in invalid_urls:
ref['url'] = invalid_url ref['url'] = invalid_url
self.post('/endpoints', self.post('/endpoints',
body={'endpoint': ref}, body={'endpoint': ref},
expected_status=http_client.BAD_REQUEST) expected_status=http.client.BAD_REQUEST)
class TestMultiRegion(test_v3.RestfulTestCase): class TestMultiRegion(test_v3.RestfulTestCase):
def test_catalog_with_multi_region_reports_all_endpoints(self): def test_catalog_with_multi_region_reports_all_endpoints(self):
# Create two separate regions # Create two separate regions
first_region = self.post( first_region = self.post(
'/regions', '/regions',
body={'region': unit.new_region_ref()} body={'region': unit.new_region_ref()}
).json_body['region'] ).json_body['region']
 End of changes. 25 change blocks. 
25 lines changed or deleted 25 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)