From 61636ecfac59fe70f130ffe2a36286b98850fd78 Mon Sep 17 00:00:00 2001 From: Thomas Dinkjian Date: Wed, 18 Feb 2015 12:39:23 -0600 Subject: [PATCH] Adds orders behaviors and smoke tests. Adds all but the put behavior for orders as well as basic positive tests, including GET, POST, DEL and GET list. Change-Id: Ic188e11b034e922c1ccecbffede34158414bc967 --- .../client/v1/behaviors/order_behaviors.py | 95 +++++++++++ .../client/v1/smoke/test_orders.py | 157 ++++++++++++++++++ 2 files changed, 252 insertions(+) create mode 100644 functionaltests/client/v1/behaviors/order_behaviors.py create mode 100644 functionaltests/client/v1/smoke/test_orders.py diff --git a/functionaltests/client/v1/behaviors/order_behaviors.py b/functionaltests/client/v1/behaviors/order_behaviors.py new file mode 100644 index 00000000..7704db22 --- /dev/null +++ b/functionaltests/client/v1/behaviors/order_behaviors.py @@ -0,0 +1,95 @@ +""" +Copyright 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 functionaltests.client.v1.behaviors import base_behaviors + + +class OrderBehaviors(base_behaviors.BaseBehaviors): + + def create_key_order(self, data): + """Create a key order from the data in the model. + + :param data: The data used to create the order + :return: The create response and href for the order + """ + + return self.client.orders.create_key(**data) + + def create_asymmetric_order(self, data): + """Create an asymmetric order from the data in the model. + + :param data: The data used to create the order + :return: The create response and href for the order + """ + + return self.client.orders.create_asymmetric(**data) + + def store_order(self, order): + """Stores an order object in the barbican database + + :return: The order href + """ + + resp = order.submit() + order_ref = str(resp) + + if order_ref: + self.created_entities.append(order_ref) + + return resp + + def get_order(self, order_ref): + """Get an order from an href. + + :param order_ref: The href for an order + :return: The response from the get + """ + return self.client.orders.get(order_ref) + + def get_orders(self, limit=10, offset=0): + """Get a list of orders. + + :param limit: limits number of returned orders (default 10) + :param offset: represents how many records to skip before retrieving + the list (default 0) + :return the response, a list of orders and the next/pref hrefs + """ + + orders = self.client.orders.list(limit, offset) + + return orders + + def delete_order(self, order_ref, expected_fail=False): + """Delete an order. + + :param order_ref: HATEOS ref of the order to be deleted + :param expected_fail: Flag telling the delete whether or not this + operation is expected to fail (ie coming + from a negative test). We need this to + determine whether or not this delete should + also remove an entity from our internal + list for housekeeping. + :return A request response object + """ + resp = self.client.orders.delete(order_ref) + if not expected_fail: + self.created_entities.remove(order_ref) + return resp + + def delete_all_created_orders(self): + """Delete all of the orders that we have created.""" + orders_to_delete = [order for order in self.created_entities] + for order_ref in orders_to_delete: + self.delete_order(order_ref) diff --git a/functionaltests/client/v1/smoke/test_orders.py b/functionaltests/client/v1/smoke/test_orders.py new file mode 100644 index 00000000..8d85cfcb --- /dev/null +++ b/functionaltests/client/v1/smoke/test_orders.py @@ -0,0 +1,157 @@ +# Copyright (c) 2015 Rackspace, Inc. +# +# 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 testtools import testcase + +from functionaltests import utils +from functionaltests.client import base +from functionaltests.client.v1.behaviors import order_behaviors + + +order_create_key_data = { + "name": "barbican functional test secret name", + "algorithm": "aes", + "bit_length": 256, + "mode": "cbc", + "payload_content_type": "application/octet-stream", +} + +# Any field with None will be created in the model with None as the value +# but will be omitted in the final request (via the requests package) +# to the server. +# +# Given that fact, order_create_nones_data is effectively an empty json request +# to the server. +order_create_nones_data = { + 'type': None, + "meta": { + "name": None, + "algorithm": None, + "bit_length": None, + "mode": None, + "payload_content_type": None, + } +} + + +@utils.parameterized_test_case +class OrdersTestCase(base.TestCase): + + def setUp(self): + super(OrdersTestCase, self).setUp() + self.behaviors = order_behaviors.OrderBehaviors( + self.barbicanclient) + + def tearDown(self): + self.behaviors.delete_all_created_orders() + super(OrdersTestCase, self).tearDown() + + @testcase.attr('positive') + def test_create_order_defaults(self): + """Covers simple order creation.""" + + test_model = self.behaviors.create_key_order(order_create_key_data) + order_ref = self.behaviors.store_order(test_model) + + self.assertIsNotNone(order_ref) + + @testcase.attr('positive') + def test_get_order_defaults_metadata(self): + """Covers order metadata. + + Assumes that the order status will be active or pending. + """ + + # first create an order + test_model = self.behaviors.create_key_order(order_create_key_data) + order_ref = self.behaviors.store_order(test_model) + + # verify that the order was created successfully + self.assertIsNotNone(order_ref) + + # given the order href, retrieve the order + order_resp = self.behaviors.get_order(order_ref) + + # verify that the get was successful + self.assertTrue(order_resp.status == "ACTIVE" or + order_resp.status == "PENDING") + + # verify the metadata + self.assertEqual(order_resp.name, + test_model.name) + self.assertEqual(order_resp.mode, + test_model.mode) + self.assertEqual(order_resp.algorithm, + test_model.algorithm) + self.assertEqual(order_resp.bit_length, + test_model.bit_length) + + @testcase.attr('positive') + def test_get_order_defaults(self): + """Covers getting an order. + + Assumes that the order status will be active or pending. + """ + + # create an order + test_model = self.behaviors.create_key_order( + order_create_key_data) + order_ref = self.behaviors.store_order(test_model) + self.assertIsNotNone(order_ref) + + # get the order + order_resp = self.behaviors.get_order(order_ref) + + # verify the order + self.assertIsNotNone(order_resp.order_ref) + self.assertEqual(order_resp._type, 'key') + self.assertTrue(order_resp.status == "ACTIVE" or + order_resp.status == "PENDING") + + if order_resp.status == "ACTIVE": + self.assertIsNotNone(order_resp.secret_ref) + + @testcase.attr('positive') + def test_delete_order_defaults(self): + """Covers simple order deletion.""" + + # create an order + test_model = self.behaviors.create_key_order( + order_create_key_data) + order_ref = self.behaviors.store_order(test_model) + + # delete the order + delete_resp = self.behaviors.delete_order(order_ref) + self.assertIsNone(delete_resp) + + @testcase.attr('positive') + def test_get_orders_defaults(self): + """Covers getting a list of orders.""" + limit = 7 + offset = 0 + total = 10 + + # create the orders + for i in range(0, total + 1): + test_model = self.behaviors.create_key_order( + order_create_key_data) + order_ref = self.behaviors.store_order(test_model) + self.assertIsNotNone(order_ref) + + # get a list of orders + orders_list = self.behaviors.get_orders( + limit=limit, offset=offset) + + # verify that the get for the list was successfu + self.assertEqual(len(orders_list), limit)