154 lines
6.1 KiB
Python
154 lines
6.1 KiB
Python
"""
|
|
Copyright 2014-2015 Rackspace
|
|
|
|
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 barbican.tests import utils
|
|
from functionaltests.api.v1.behaviors import base_behaviors
|
|
from functionaltests.api.v1.models import container_models
|
|
|
|
|
|
class ContainerBehaviors(base_behaviors.BaseBehaviors):
|
|
|
|
def create_container(self, model, extra_headers=None,
|
|
user_name=None, admin=None):
|
|
"""Create a container from the data in the model.
|
|
|
|
:param model: The metadata used to create the container
|
|
:param extra_headers: Headers used to create the container
|
|
:param user_name: The user name used to create the container
|
|
:param admin: The user with permissions to delete the container
|
|
:return: A tuple containing the response from the create
|
|
and the href to the newly created container
|
|
"""
|
|
|
|
resp = self.client.post('containers', request_model=model,
|
|
extra_headers=extra_headers,
|
|
user_name=user_name)
|
|
|
|
returned_data = self.get_json(resp)
|
|
container_ref = returned_data.get('container_ref')
|
|
if container_ref:
|
|
if admin is None:
|
|
admin = user_name
|
|
self.created_entities.append((container_ref, admin))
|
|
return resp, container_ref
|
|
|
|
def get_container(self, container_ref, extra_headers=None, user_name=None):
|
|
"""Handles getting a single container
|
|
|
|
:param container_ref: Reference to the container to be retrieved
|
|
:param extra_headers: Headers used to get the container
|
|
:param user_name: The user name used to get the container
|
|
|
|
:return: The response of the GET.
|
|
"""
|
|
resp = self.client.get(
|
|
container_ref, response_model_type=container_models.ContainerModel,
|
|
user_name=user_name, extra_headers=extra_headers)
|
|
|
|
return resp
|
|
|
|
def get_containers(self, limit=10, offset=0, filter=None,
|
|
extra_headers=None, user_name=None):
|
|
"""Handles getting a list of containers.
|
|
|
|
:param limit: limits number of returned containers
|
|
:param offset: represents how many records to skip before retrieving
|
|
the list
|
|
:param filter: allows you to filter results based on name
|
|
:param extra_headers: Extra headers used to retrieve a list of
|
|
containers
|
|
:param user_name: The user name used to get the list
|
|
|
|
:return: Returns the response, a list of container models, and
|
|
references to the next and previous list of containers.
|
|
"""
|
|
params = {'limit': limit, 'offset': offset}
|
|
|
|
if filter:
|
|
params['name'] = filter
|
|
|
|
resp = self.client.get('containers', params=params,
|
|
extra_headers=extra_headers,
|
|
user_name=user_name)
|
|
|
|
container_list = self.get_json(resp)
|
|
|
|
containers, next_ref, prev_ref = self.client.get_list_of_models(
|
|
container_list, container_models.ContainerModel)
|
|
|
|
return resp, containers, next_ref, prev_ref
|
|
|
|
def delete_container(self, container_ref, extra_headers=None,
|
|
expected_fail=False, user_name=None):
|
|
"""Handles deleting a containers.
|
|
|
|
:param container_ref: Reference of the container to be deleted
|
|
:param extra_headers: Any additional headers needed.
|
|
:param expected_fail: If there is a negative test, this should be
|
|
marked true if you are trying to delete a container that does
|
|
not exist.
|
|
:param user_name: The user name used to delete the container
|
|
:return: Response of the delete.
|
|
"""
|
|
resp = self.client.delete(container_ref, extra_headers,
|
|
user_name=user_name)
|
|
|
|
if not expected_fail:
|
|
for item in self.created_entities:
|
|
if item[0] == container_ref:
|
|
self.created_entities.remove(item)
|
|
|
|
return resp
|
|
|
|
def delete_all_created_containers(self):
|
|
"""Delete all of the containers that we have created."""
|
|
entities = list(self.created_entities)
|
|
for (container_ref, admin) in entities:
|
|
self.delete_container(container_ref, user_name=admin)
|
|
|
|
def update_container(self, container_ref, user_name=None):
|
|
"""Attempt to update a container (which is an invalid operation)
|
|
|
|
Update (HTTP PUT) is not supported against a container resource, so
|
|
issuing this call should fail.
|
|
|
|
:param container_ref: Reference of the container to be updated
|
|
:param user_name: The user name used to update the container
|
|
:return: Response of the update.
|
|
"""
|
|
|
|
resp = self.client.put(container_ref, user_name=user_name)
|
|
|
|
return resp
|
|
|
|
def delete_all_containers_for_user(self, user_name):
|
|
'''Delete all of the containers for the specified user'''
|
|
response, containers, next_ref, prev_ref = self.get_containers(
|
|
user_name=user_name)
|
|
container_refs_to_delete = []
|
|
while len(containers) > 0:
|
|
for container in containers:
|
|
container_refs_to_delete.append(container.container_ref)
|
|
if next_ref:
|
|
limit, offset = utils.get_limit_and_offset_from_ref(next_ref)
|
|
response, containers, next_ref, prev = self.get_containers(
|
|
limit=limit, offset=offset, user_name=user_name)
|
|
else:
|
|
break
|
|
|
|
for container_ref in container_refs_to_delete:
|
|
self.delete_container(container_ref=container_ref,
|
|
user_name=user_name)
|