# Copyright (c) 2013-2014 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. import datetime import unittest from barbican.common import exception as excep from barbican.common import validators from barbican.tests import utils def suite(): suite = unittest.TestSuite() suite.addTest(WhenTestingSecretValidator()) return suite class WhenTestingValidatorsFunctions(utils.BaseTestCase): def test_secret_too_big_is_false_for_small_secrets(self): data = b'\xb0' is_too_big = validators.secret_too_big(data) self.assertFalse(is_too_big) def test_secret_too_big_is_true_for_big_secrets(self): data = b'\x01' * validators.CONF.max_allowed_secret_in_bytes data += b'\x01' is_too_big = validators.secret_too_big(data) self.assertTrue(is_too_big) def test_secret_too_big_is_true_for_big_unicode_secrets(self): beer = u'\U0001F37A' data = beer * (validators.CONF.max_allowed_secret_in_bytes / 4) data += u'1' is_too_big = validators.secret_too_big(data) self.assertTrue(is_too_big) class WhenTestingSecretValidator(utils.BaseTestCase): def setUp(self): super(WhenTestingSecretValidator, self).setUp() self.name = 'name' self.payload = b'not-encrypted' self.payload_content_type = 'text/plain' self.secret_algorithm = 'algo' self.secret_bit_length = 512 self.secret_mode = 'cytype' self.secret_req = {'name': self.name, 'payload_content_type': self.payload_content_type, 'algorithm': self.secret_algorithm, 'bit_length': self.secret_bit_length, 'mode': self.secret_mode, 'payload': self.payload} self.validator = validators.NewSecretValidator() def test_should_validate_all_fields(self): self.validator.validate(self.secret_req) def test_should_validate_no_name(self): del self.secret_req['name'] self.validator.validate(self.secret_req) def test_should_validate_empty_name(self): self.secret_req['name'] = ' ' self.validator.validate(self.secret_req) def test_should_validate_no_payload(self): del self.secret_req['payload'] del self.secret_req['payload_content_type'] result = self.validator.validate(self.secret_req) self.assertFalse('payload' in result) def test_should_validate_payload_with_whitespace(self): self.secret_req['payload'] = ' ' + self.payload + ' ' result = self.validator.validate(self.secret_req) self.assertEqual(self.payload, result['payload']) def test_should_validate_future_expiration(self): self.secret_req['expiration'] = '2114-02-28T19:14:44.180394' result = self.validator.validate(self.secret_req) self.assertTrue('expiration' in result) self.assertTrue(isinstance(result['expiration'], datetime.datetime)) def test_should_validate_future_expiration_no_t(self): self.secret_req['expiration'] = '2114-02-28 19:14:44.180394' result = self.validator.validate(self.secret_req) self.assertTrue('expiration' in result) self.assertTrue(isinstance(result['expiration'], datetime.datetime)) def test_should_validate_expiration_with_z(self): expiration = '2114-02-28 19:14:44.180394Z' self.secret_req['expiration'] = expiration result = self.validator.validate(self.secret_req) self.assertTrue('expiration' in result) self.assertTrue(isinstance(result['expiration'], datetime.datetime)) self.assertEqual(expiration[:-1], str(result['expiration'])) def test_should_validate_expiration_with_tz(self): expiration = '2114-02-28 12:14:44.180394-05:00' self.secret_req['expiration'] = expiration result = self.validator.validate(self.secret_req) self.assertTrue('expiration' in result) self.assertTrue(isinstance(result['expiration'], datetime.datetime)) expected = expiration[:-6].replace('12', '17', 1) self.assertEqual(expected, str(result['expiration'])) def test_should_validate_expiration_extra_whitespace(self): expiration = '2114-02-28 12:14:44.180394-05:00 ' self.secret_req['expiration'] = expiration result = self.validator.validate(self.secret_req) self.assertTrue('expiration' in result) self.assertTrue(isinstance(result['expiration'], datetime.datetime)) expected = expiration[:-12].replace('12', '17', 1) self.assertEqual(expected, str(result['expiration'])) def test_should_validate_empty_expiration(self): self.secret_req['expiration'] = ' ' result = self.validator.validate(self.secret_req) self.assertTrue('expiration' in result) self.assertTrue(not result['expiration']) def test_should_raise_numeric_name(self): self.secret_req['name'] = 123 exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) self.assertEqual('name', exception.invalid_property) def test_should_raise_negative_bit_length(self): self.secret_req['bit_length'] = -23 exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) self.assertEqual('bit_length', exception.invalid_property) def test_should_raise_non_integer_bit_length(self): self.secret_req['bit_length'] = "23" exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) self.assertEqual('bit_length', exception.invalid_property) def test_validation_should_raise_with_empty_payload(self): self.secret_req['payload'] = ' ' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) self.assertEqual('payload', exception.invalid_property) def test_should_raise_already_expired(self): self.secret_req['expiration'] = '2004-02-28T19:14:44.180394' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) self.assertEqual('expiration', exception.invalid_property) def test_should_raise_expiration_nonsense(self): self.secret_req['expiration'] = 'nonsense' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) self.assertEqual('expiration', exception.invalid_property) def test_should_raise_all_nulls(self): self.secret_req = {'name': None, 'algorithm': None, 'bit_length': None, 'mode': None} self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) def test_should_raise_all_empties(self): self.secret_req = {'name': '', 'algorithm': '', 'bit_length': '', 'mode': ''} self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) def test_should_raise_no_payload_content_type(self): del self.secret_req['payload_content_type'] self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) def test_should_raise_with_message_w_bad_payload_content_type(self): self.secret_req['payload_content_type'] = 'plain/text' try: self.validator.validate(self.secret_req) except excep.InvalidObject as e: self.assertNotEqual(str(e), 'None') self.assertIsNotNone(e.message) self.assertNotEqual(e.message, 'None') else: self.fail('No validation exception was raised') def test_should_validate_mixed_case_payload_content_type(self): self.secret_req['payload_content_type'] = 'TeXT/PlaiN' self.validator.validate(self.secret_req) def test_should_validate_upper_case_payload_content_type(self): self.secret_req['payload_content_type'] = 'TEXT/PLAIN' self.validator.validate(self.secret_req) def test_should_raise_with_mixed_case_wrong_payload_content_type(self): self.secret_req['payload_content_type'] = 'TeXT/PlaneS' self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) def test_should_raise_with_upper_case_wrong_payload_content_type(self): self.secret_req['payload_content_type'] = 'TEXT/PLANE' self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) def test_should_raise_with_plain_text_and_encoding(self): self.secret_req['payload_content_encoding'] = 'base64' self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) def test_should_raise_with_wrong_encoding(self): self.secret_req['payload_content_type'] = 'application/octet-stream' self.secret_req['payload_content_encoding'] = 'unsupported' self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) def test_should_validate_with_wrong_encoding(self): self.secret_req['payload_content_type'] = 'application/octet-stream' self.secret_req['payload_content_encoding'] = 'base64' self.validator.validate(self.secret_req) class WhenTestingOrderValidator(utils.BaseTestCase): def setUp(self): super(WhenTestingOrderValidator, self).setUp() self.name = 'name' self.secret_algorithm = 'aes' self.secret_bit_length = 128 self.secret_mode = 'cbc' self.secret_payload_content_type = 'application/octet-stream' self.secret_req = {'name': self.name, 'algorithm': self.secret_algorithm, 'bit_length': self.secret_bit_length, 'mode': self.secret_mode, 'payload_content_type': self.secret_payload_content_type} self.order_req = {'secret': self.secret_req} self.validator = validators.NewOrderValidator() def test_should_validate_all_fields(self): self.validator.validate(self.order_req) def test_should_validate_no_name(self): del self.secret_req['name'] result = self.validator.validate(self.order_req) self.assertTrue('secret' in result) def test_should_validate_empty_name(self): self.secret_req['name'] = ' ' result = self.validator.validate(self.order_req) self.assertTrue('secret' in result) def test_should_validate_future_expiration(self): self.secret_req['expiration'] = '2114-02-28T19:14:44.180394' result = self.validator.validate(self.order_req) self.assertTrue('secret' in result) result = result['secret'] self.assertTrue('expiration' in result) self.assertTrue(isinstance(result['expiration'], datetime.datetime)) def test_should_validate_empty_expiration(self): self.secret_req['expiration'] = ' ' result = self.validator.validate(self.order_req) self.assertTrue('secret' in result) result = result['secret'] self.assertTrue('expiration' in result) self.assertTrue(not result['expiration']) def test_should_raise_numeric_name(self): self.secret_req['name'] = 123 exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req, ) self.assertEqual('name', exception.invalid_property) def test_should_raise_bad_mode(self): self.secret_req['mode'] = 'badmode' exception = self.assertRaises( excep.UnsupportedField, self.validator.validate, self.order_req, ) self.assertEqual('mode', exception.invalid_field) def test_should_raise_negative_bit_length(self): self.secret_req['bit_length'] = -23 exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req, ) self.assertEqual('bit_length', exception.invalid_property) def test_should_raise_non_integer_bit_length(self): self.secret_req['bit_length'] = "23" exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req, ) self.assertEqual('bit_length', exception.invalid_property) def test_should_raise_non_multiple_eight_bit_length(self): self.secret_req['bit_length'] = 129 exception = self.assertRaises( excep.UnsupportedField, self.validator.validate, self.order_req, ) self.assertEqual('bit_length', exception.invalid_field) def test_should_raise_secret_not_order_schema_provided(self): exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.secret_req, ) self.assertEqual('secret', exception.invalid_property) def test_should_raise_payload_provided(self): self.secret_req['payload'] = ' ' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req, ) self.assertTrue('payload' in exception.invalid_property) def test_should_raise_already_expired(self): self.secret_req['expiration'] = '2004-02-28T19:14:44.180394' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req, ) self.assertEqual('expiration', exception.invalid_property) def test_should_raise_expiration_nonsense(self): self.secret_req['expiration'] = 'nonsense' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req, ) self.assertEqual('expiration', exception.invalid_property) def test_should_raise_all_nulls(self): self.secret_req = {'name': None, 'algorithm': None, 'bit_length': None, 'mode': None} self.order_req = {'secret': self.secret_req} self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req, ) def test_should_raise_all_empties(self): self.secret_req = {'name': '', 'algorithm': '', 'bit_length': '', 'mode': ''} self.order_req = {'secret': self.secret_req} self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req, ) def test_should_raise_no_payload_content_type(self): del self.secret_req['payload_content_type'] self.assertRaises( excep.UnsupportedField, self.validator.validate, self.order_req, ) def test_should_raise_unsupported_payload_content_type(self): self.secret_req['payload_content_type'] = 'text/plain' self.assertRaises( excep.UnsupportedField, self.validator.validate, self.order_req, ) def test_should_raise_empty_mode(self): del self.secret_req['mode'] exception = self.assertRaises( excep.UnsupportedField, self.validator.validate, self.order_req, ) self.assertEqual('mode', exception.invalid_field) def test_should_raise_empty_algorithm(self): del self.secret_req['algorithm'] exception = self.assertRaises( excep.UnsupportedField, self.validator.validate, self.order_req, ) self.assertEqual('algorithm', exception.invalid_field) def test_should_raise_invalid_json_data_type(self): self.assertRaises( excep.InvalidObject, self.validator.validate, [], ) def test_should_raise_payload_in_secret(self): self.order_req['secret']['payload'] = "YWJjZGVmZw==" self.order_req['secret']['payload_content_encoding'] = 'base64' self.assertRaises( excep.InvalidObject, self.validator.validate, self.order_req ) class WhenTestingContainerValidator(utils.BaseTestCase): def setUp(self): super(WhenTestingContainerValidator, self).setUp() self.name = 'name' self.type = 'generic' self.secret_refs = [ { 'name': 'testname', 'secret_ref': '1231' }, { 'name': 'testname2', 'secret_ref': '1232' } ] self.container_req = {'name': self.name, 'type': self.type, 'secret_refs': self.secret_refs} self.validator = validators.ContainerValidator() def test_should_validate_all_fields(self): self.validator.validate(self.container_req) def test_should_validate_no_name(self): del self.container_req['name'] self.validator.validate(self.container_req) def test_should_validate_empty_name(self): self.container_req['name'] = ' ' self.validator.validate(self.container_req) def test_should_raise_no_type(self): del self.container_req['type'] self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) # TODO(hgedikli): figure out why invalid_property is null here # self.assertEqual('type', e.exception.invalid_property) def test_should_raise_empty_type(self): self.container_req['type'] = '' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('type', exception.invalid_property) def test_should_raise_not_supported_type(self): self.container_req['type'] = 'testtype' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('type', exception.invalid_property) def test_should_raise_numeric_name(self): self.container_req['name'] = 123 exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('name', exception.invalid_property) def test_should_raise_all_nulls(self): self.container_req = {'name': None, 'type': None, 'bit_length': None, 'secret_refs': None} self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) def test_should_raise_all_empties(self): self.container_req = {'name': '', 'type': '', 'secret_refs': []} self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) def test_should_validate_empty_secret_refs(self): self.container_req['secret_refs'] = [] self.validator.validate(self.container_req) def test_should_raise_no_secret_ref_in_secret_refs(self): del self.container_req['secret_refs'][0]['secret_ref'] self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) def test_should_raise_empty_secret_ref_in_secret_refs(self): self.container_req['secret_refs'][0]['secret_ref'] = '' self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) def test_should_raise_numeric_secret_ref_in_secret_refs(self): self.container_req['secret_refs'][0]['secret_ref'] = 123 self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) def test_should_raise_duplicate_names_in_secret_refs(self): self.container_req['secret_refs'].append( self.container_req['secret_refs'][0]) exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_duplicate_secret_ids_in_secret_refs(self): secret_ref = self.container_req['secret_refs'][0] secret_ref['name'] = 'testname3' self.container_req['secret_refs'].append(secret_ref) exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_duplicate_secret_ref_format_ids_in_secret_refs(self): """Test duplicate secret_id presence as part of single container. Here secret_id is represented in different format and secret_id is extracted from there. """ secret_refs = [ { 'name': 'testname', 'secret_ref': 'http://localhost:9311/v1/12345/secrets/1231' }, { 'name': 'testname2', 'secret_ref': 'http://localhost:9311/v1/12345/secrets//1232' }, { 'name': 'testname3', 'secret_ref': 'http://localhost:9311/v1/12345/secrets//1231/' } ] container_req = {'name': 'name', 'type': 'generic', 'secret_refs': secret_refs} exception = self.assertRaises( excep.InvalidObject, self.validator.validate, container_req, ) self.assertEqual('secret_refs', exception.invalid_property) class WhenTestingRSAContainerValidator(utils.BaseTestCase): def setUp(self): super(WhenTestingRSAContainerValidator, self).setUp() self.name = 'name' self.type = 'rsa' self.secret_refs = [ { 'name': 'public_key', 'secret_ref': '1231' }, { 'name': 'private_key', 'secret_ref': '1232' }, { 'name': 'private_key_passphrase', 'secret_ref': '1233' } ] self.container_req = {'name': self.name, 'type': self.type, 'secret_refs': self.secret_refs} self.validator = validators.ContainerValidator() def test_should_validate_all_fields(self): self.validator.validate(self.container_req) def test_should_raise_no_names_in_secret_refs(self): del self.container_req['secret_refs'][0]['name'] exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_empty_names_in_secret_refs(self): self.container_req['secret_refs'][0]['name'] = '' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_unsupported_names_in_secret_refs(self): self.container_req['secret_refs'][0]['name'] = 'testttt' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_duplicate_secret_id_in_secret_refs(self): self.container_req['secret_refs'][0]['secret_ref'] = ( self.container_req['secret_refs'][2]['secret_ref']) exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_more_than_3_secret_refs(self): new_secret_ref = { 'name': 'new secret ref', 'secret_ref': '234234' } self.container_req['secret_refs'].append(new_secret_ref) exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req, ) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_if_required_name_missing(self): name = 'name' type = 'certificate' secret_refs = [ { 'name': 'private_key', 'secret_ref': '123' }, { 'name': 'private_key_passphrase', 'secret_ref': '123' } ] container_req = {'name': name, 'type': type, 'secret_refs': secret_refs} exception = self.assertRaises( excep.InvalidObject, self.validator.validate, container_req) self.assertEqual('secret_refs', exception.invalid_property) class WhenTestingCertificateContainerValidator(utils.BaseTestCase): def setUp(self): super(WhenTestingCertificateContainerValidator, self).setUp() self.name = 'name' self.type = 'certificate' self.secret_refs = [ { 'name': 'certificate', 'secret_ref': 'S4dfsdrf' }, { 'name': 'private_key', 'secret_ref': '1231' }, { 'name': 'private_key_passphrase', 'secret_ref': '1232' }, { 'name': 'intermediates', 'secret_ref': '1233' } ] self.container_req = {'name': self.name, 'type': self.type, 'secret_refs': self.secret_refs} self.validator = validators.ContainerValidator() def test_should_validate_all_fields(self): self.validator.validate(self.container_req) def test_should_raise_more_than_4_secret_refs(self): new_secret_ref = { 'name': 'new secret ref', 'secret_ref': '234234' } self.container_req['secret_refs'].append(new_secret_ref) exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_unsupported_names_in_secret_refs(self): self.container_req['secret_refs'][0]['name'] = 'public_key' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.container_req) self.assertEqual('secret_refs', exception.invalid_property) def test_should_raise_if_required_name_missing(self): name = 'name' type = 'certificate' secret_refs = [ { 'name': 'private_key', 'secret_ref': '123' }, { 'name': 'intermediates', 'secret_ref': '123' } ] container_req = {'name': name, 'type': type, 'secret_refs': secret_refs} exception = self.assertRaises( excep.InvalidObject, self.validator.validate, container_req) self.assertEqual('secret_refs', exception.invalid_property) class WhenTestingTransportKeyValidator(utils.BaseTestCase): def setUp(self): super(WhenTestingTransportKeyValidator, self).setUp() self.plugin_name = 'name' self.transport_key = 'abcdef' self.transport_req = {'plugin_name': self.plugin_name, 'transport_key': self.transport_key} self.validator = validators.NewTransportKeyValidator() def test_should_raise_with_invalid_json_data_type(self): self.assertRaises( excep.InvalidObject, self.validator.validate, [] ) def test_should_raise_with_empty_transport_key(self): self.transport_req['transport_key'] = '' exception = self.assertRaises( excep.InvalidObject, self.validator.validate, self.transport_req ) self.assertEqual('transport_key', exception.invalid_property) class WhenTestingConsumerValidator(utils.BaseTestCase): def setUp(self): super(WhenTestingConsumerValidator, self).setUp() self.name = 'name' self.URL = 'http://my.url/resource/UUID' self.consumer_req = {'name': self.name, 'URL': self.URL} self.validator = validators.ContainerConsumerValidator() def test_should_raise_with_invalid_json_data_type(self): self.assertRaises( excep.InvalidObject, self.validator.validate, [] ) def test_should_raise_with_missing_name(self): consumer_req = {'URL': self.URL} exception = self.assertRaises( excep.InvalidObject, self.validator.validate, consumer_req ) self.assertIn('\'name\'', exception.args[0]) def test_should_raise_with_missing_URL(self): consumer_req = {'name': self.name} exception = self.assertRaises( excep.InvalidObject, self.validator.validate, consumer_req ) self.assertIn('\'URL\'', exception.args[0]) def test_should_validate_all_fields(self): self.validator.validate(self.consumer_req) class WhenTestingTypeOrderValidator(utils.BaseTestCase): def setUp(self): super(WhenTestingTypeOrderValidator, self).setUp() self.type = 'key' self.meta = {"name": "secretname", "algorithm": "AES", "bit_length": 256, "mode": "cbc", 'payload_content_type': 'application/octet-stream'} self.order_req = {'type': self.type, 'meta': self.meta} self.validator = validators.TypeOrderValidator() def test_should_pass_with_certificate_type_in_order_refs(self): self.order_req['type'] = 'certificate' result = self.validator.validate(self.order_req) self.assertEqual('certificate', result['type']) def test_should_pass_good_bit_meta_in_order_refs(self): self.order_req['meta']['algorithm'] = 'AES' self.order_req['meta']['bit_length'] = 256 result = self.validator.validate(self.order_req) self.assertTrue(result['meta']['expiration'] is None) def test_should_pass_good_exp_meta_in_order_refs(self): self.order_req['meta']['algorithm'] = 'AES' ony_year_factor = datetime.timedelta(days=1 * 365) date_after_year = datetime.datetime.now() + ony_year_factor date_after_year_str = date_after_year.strftime('%Y-%m-%d %H:%M:%S') self.order_req['meta']['expiration'] = date_after_year_str result = self.validator.validate(self.order_req) self.assertTrue('expiration' in result['meta']) self.assertTrue(isinstance(result['meta']['expiration'], datetime.datetime)) def test_should_raise_with_no_type_in_order_refs(self): del self.order_req['type'] exception = self.assertRaises(excep.InvalidObject, self.validator.validate, self.order_req) self.assertEqual('type', exception.invalid_property) def test_should_raise_with_bad_type_in_order_refs(self): self.order_req['type'] = 'badType' exception = self.assertRaises(excep.InvalidObject, self.validator.validate, self.order_req) self.assertEqual('type', exception.invalid_property) def test_should_raise_with_no_meta_in_order_refs(self): del self.order_req['meta'] exception = self.assertRaises(excep.InvalidObject, self.validator.validate, self.order_req) self.assertEqual('meta', exception.invalid_property) def test_should_raise_with_wrong_exp_meta_in_order_refs(self): self.order_req['meta']['algorithm'] = 'AES' self.order_req['meta']['expiration'] = '2014-02-28T19:14:44.180394' exception = self.assertRaises(excep.InvalidObject, self.validator.validate, self.order_req) self.assertEqual('expiration', exception.invalid_property) if __name__ == '__main__': unittest.main()