openstack/python-barbicanclient
Code Issues Proposed changes

Adds orders behaviors and smoke tests.

Browse Source 
Adds all but the put behavior for orders as well as basic positive tests,
including GET, POST, DEL and GET list.

Change-Id: Ic188e11b034e922c1ccecbffede34158414bc967
This commit is contained in:
Thomas Dinkjian
2015-02-18 12:39:23 -06:00
parent a982ac7e06
commit 61636ecfac
2 changed files with 252 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
functionaltests/client/v1/behaviors/order_behaviors.py Normal file
View File

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

157
functionaltests/client/v1/smoke/test_orders.py Normal file
View File

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