def test_schema_correct(self): assert SettingsOneTwoThree.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), 'baz': fields.Dictionary( { 'inner_foo': fields.UnicodeString(), 'inner_bar': fields.Boolean(), 'inner_baz': fields.List(fields.Integer()), 'inner_qux': fields.Dictionary( { 'most_inner_foo': fields.Boolean(), 'most_inner_bar': fields.UnicodeString(), }, ), }, ), 'qux': fields.Float(), }
class SettingsToTest(settings.Settings): schema: settings.SettingsSchema = { 'one': fields.Dictionary({ 'a': fields.ClassConfigurationSchema(base_class=ClassUsingAttrs27HintsToTest, description='Nifty schema.'), 'b': fields.PythonPath(value_schema=fields.UnicodeString(), description='Must be a path, yo.'), 'c': fields.TypeReference(base_classes=ClassHoldingSigsToTest, description='Refer to that thing!'), }), 'two': fields.SchemalessDictionary(key_type=fields.UnicodeString(), value_type=fields.Boolean()), 'three': fields.List(fields.Integer()), 'four': fields.Nullable(fields.Set(fields.ByteString())), 'five': fields.Any(fields.Integer(), fields.Float()), 'six': fields.ObjectInstance(valid_type=ClassUsingAttrs27HintsToTest, description='Y u no instance?'), 'seven': fields.Polymorph( 'thing', { 'thing1': fields.Dictionary({'z': fields.Boolean()}, allow_extra_keys=True), 'thing2': fields.Dictionary({'y': fields.Boolean()}, allow_extra_keys=True, optional_keys=('y', )), }, ), } defaults: settings.SettingsData = { 'one': { 'b': 'foo.bar:Class', }, 'three': [1, 5, 7], }
class SettingsTwo(Settings): schema = { 'bar': fields.Integer(), 'baz': fields.Dictionary( { 'inner_foo': fields.UnicodeString(), 'inner_bar': fields.Boolean(), 'inner_baz': fields.List(fields.Integer()), 'inner_qux': fields.Dictionary( { 'most_inner_foo': fields.Boolean(), 'most_inner_bar': fields.UnicodeString(), }, ), }, ), } # type: SettingsSchema defaults = { 'bar': 1, 'baz': { 'inner_foo': 'Default inner', 'inner_qux': { 'most_inner_bar': 'Default most inner' } }, } # type: SettingsData
class BasicClassSchema(fields.Dictionary): contents = { 'path': fields.UnicodeString( description= 'The path to the class to be imported and used, in the format `module.name:ClassName`', ), 'kwargs': fields.SchemalessDictionary( key_type=fields.UnicodeString(), description= 'Any keyword arguments that should be passed to the class when constructing a new instance', ), } optional_keys = ['kwargs'] object_type = None def __init__(self, object_type=None, **kwargs): super(BasicClassSchema, self).__init__(**kwargs) if object_type: assert isinstance(object_type, type) self.object_type = object_type def __repr__(self): return '{class_name}({object_type})'.format( class_name=self.__class__.__name__, object_type='object_type={module_name}:{class_name}'.format( module_name=self.object_type.__module__, class_name=self.object_type.__name__, ) if self.object_type else '', )
class SettingsWithDefaults(Settings): schema = { 'complex_property': fields.Dictionary({ 'string_property': fields.UnicodeString(), 'int_property': fields.Integer(), 'kwargs': fields.Dictionary({ 'foo': fields.Integer(), 'bar': fields.UnicodeString(), }), }), 'simple_property': fields.Integer(), } defaults = { 'simple_property': 0, 'complex_property': { 'string_property': 'default_string', 'kwargs': { 'foo': 1, }, }, }
class MockingTestAction(Action): request_schema = fields.Dictionary({ 'min': fields.Integer(), 'max': fields.Integer(), 'kwargs': fields.SchemalessDictionary(key_type=fields.UnicodeString()), }) response_schema = fields.Dictionary({ 'random': fields.Integer(), 'response': fields.SchemalessDictionary(), 'extra': fields.UnicodeString(), }) def run(self, request): try: # noinspection PyUnresolvedReferences return { 'random': random.randint(request.body['min'], request.body['max']), 'response': function_which_shall_be_mocked( request.body['max'], request.body['min'], **request.body['kwargs'] ), 'extra': function_which_shall_be_mocked.extra.value().for_me, } except AttributeError: raise ActionError(errors=[Error('ATTRIBUTE_ERROR', 'An attribute error was raised')]) except BytesWarning: raise ActionError(errors=[Error('BYTES_WARNING', 'A bytes warning was raised')]) except ExpectedException: raise ActionError(errors=[Error('EXPECTED_EXCEPTION', 'An expected exception was raised')])
def test_schema_correct(self): assert SettingsTwoFour.schema == { 'bar': fields.Integer(), 'baz': fields.Dictionary( { 'inner_foo': fields.UnicodeString(), 'inner_bar': fields.Boolean(), 'inner_baz': fields.List(fields.Integer()), 'inner_qux': fields.Dictionary( { 'most_inner_foo': fields.Boolean(), 'most_inner_bar': fields.UnicodeString(), }, ), }, ), 'qux': fields.Decimal(), 'new': fields.ByteString(), 'old': fields.UnicodeString(), }
class LocalClientTransportSchema(BasicClassSchema): contents = { 'path': fields.UnicodeString( description='The path to the local client transport, in the format `module.name:ClassName`', ), 'kwargs': fields.Dictionary({ # server class can be an import path or a class object 'server_class': fields.Any( fields.UnicodeString( description='The path to the `Server` class, in the format `module.name:ClassName`', ), fields.ObjectInstance( six.class_types, description='A reference to the `Server`-extending class/type', ), description='The path to the `Server` class to use locally (as a library), or a reference to the ' '`Server`-extending class/type itself', ), # No deeper validation because the Server will perform its own validation 'server_settings': fields.SchemalessDictionary( key_type=fields.UnicodeString(), description='The settings to use when instantiating the `server_class`' ), }), } optional_keys = () description = 'The settings for the local client transport'
def test_schema_correct(self): assert SettingsOneFour.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), 'baz': fields.List(fields.Float()), 'qux': fields.Decimal(), 'new': fields.ByteString(), 'old': fields.UnicodeString(), }
def test_schema_correct(self): assert SettingsOneTwoThreeWithOverridesExtended.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), 'baz': fields.ByteString(), 'qux': fields.Decimal(), 'new': fields.ByteString(), 'old': fields.UnicodeString(), }
class LoginAction(Action): request_schema = fields.Dictionary({'username': fields.UnicodeString()}) response_schema = fields.Dictionary( {'session': fields.Dictionary({'session_id': fields.UnicodeString(), 'user': fields.UnicodeString()})}, ) def run(self, request): return {'session': {'session_id': six.text_type(uuid.uuid4().hex), 'user': request.body['username']}}
class Http2TransportSchema(fields.Dictionary): contents = { 'backend_layer_kwargs': fields.Dictionary( { 'http_host': fields.UnicodeString(), 'http_port': fields.UnicodeString(), }, optional_keys=(), allow_extra_keys=False, ), 'backend_type': fields.Constant( *HTTP2_BACKEND_TYPES, description= 'Which backend (hyper-h2 or twisted) should be used for this Http2 transport' ), 'message_expiry_in_seconds': fields.Integer( description= 'How long after a message is sent that it is considered expired, dropped from queue', ), 'queue_capacity': fields.Integer( description= 'The capacity of the message queue to which this transport will send messages', ), 'queue_full_retries': fields.Integer( description= 'How many times to retry sending a message to a full queue before giving up', ), 'receive_timeout_in_seconds': fields.Integer( description='How long to block waiting on a message to be received', ), 'default_serializer_config': fields.ClassConfigurationSchema( base_class=BaseSerializer, description= 'The configuration for the serializer this transport should use.', ), } optional_keys = ( 'backend_layer_kwargs', 'message_expiry_in_seconds', 'queue_capacity', 'queue_full_retries', 'receive_timeout_in_seconds', 'default_serializer_config', ) description = 'The constructor kwargs for the Http2 client and server transports.'
class FakeActionTwo(object): """Test action documentation""" request_schema = fields.UnicodeString(description='Be weird.') response_schema = fields.Dictionary({ 'okay': fields.Boolean(description='Whether it is okay'), 'reason': fields.Nullable( fields.UnicodeString(description='Why it is not okay')), })
class LocalTransportSchema(BasicClassSchema): contents = { 'path': fields.UnicodeString(), 'kwargs': fields.Dictionary({ # server class can be an import path or a class object 'server_class': fields.Any(fields.UnicodeString(), fields.ObjectInstance(six.class_types)), # No deeper validation because the Server will perform its own validation 'server_settings': fields.SchemalessDictionary(key_type=fields.UnicodeString()), }), }
class ActionOne(Action): request_schema = fields.Dictionary({'planet': fields.UnicodeString()}) response_schema = fields.Dictionary({ 'planet_response': fields.UnicodeString(), 'settings': fields.Anything() }) def run(self, request): return { 'planet_response': request.body['planet'], 'settings': self.settings }
class TypesEchoAction(Action): request_schema = fields.Dictionary( { 'an_int': fields.Integer(), 'a_float': fields.Float(), 'a_bool': fields.Boolean(), 'a_bytes': fields.ByteString(), 'a_string': fields.UnicodeString(), 'a_datetime': fields.DateTime(), 'a_date': fields.Date(), 'a_time': fields.Time(), 'a_list': fields.List(fields.Anything(), max_length=0), 'a_dict': fields.Nullable(fields.Dictionary({})), }, optional_keys=( 'an_int', 'a_float', 'a_bool', 'a_bytes', 'a_string', 'a_datetime', 'a_date', 'a_time', 'a_list', 'a_dict', ), ) response_schema = fields.Dictionary( {'r_{}'.format(k): v for k, v in six.iteritems(request_schema.contents)}, optional_keys=('r_{}'.format(k) for k in request_schema.optional_keys), ) def run(self, request): return {'r_{}'.format(k): v for k, v in six.iteritems(request.body)}
def test_schema_correct(self): assert SettingsThreeTwoOne.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Integer(), 'baz': fields.List(fields.Float()), 'qux': fields.Float(), }
def test_schema_correct(self): assert SettingsOneThree.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), 'baz': fields.List(fields.Float()), 'qux': fields.Float(), }
def test_schema_correct(self): assert SettingsOneTwoThreeWithOverrides.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), 'baz': fields.ByteString(), 'qux': fields.Float(), }
def test_schema_correct(self): assert SettingsTwoFourWithOverrides.schema == { 'bar': fields.Integer(), 'baz': fields.ByteString(), 'qux': fields.Decimal(), 'new': fields.ByteString(), 'old': fields.UnicodeString(), }
class SettingsOne(Settings): schema = { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), } # type: SettingsSchema defaults = { 'bar': False, } # type: SettingsData
class LocalServerTransportSchema(BasicClassSchema): contents = { 'path': fields.UnicodeString( description='The path to the local server transport, in the format `module.name:ClassName`', ), 'kwargs': fields.Dictionary({}), } description = 'The settings for the local client transport'
class NotASettings(object): schema = { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), } # type: SettingsSchema defaults = { 'bar': False, } # type: SettingsData
class StubClientTransportSchema(BasicClassSchema): contents = { 'path': fields.UnicodeString( description= 'The path to the stub client transport, in the format `module.name:ClassName`', ), 'kwargs': fields.Dictionary( { 'action_map': fields.SchemalessDictionary( key_type=fields.UnicodeString( description='The name of the action to stub', ), value_type=fields.Dictionary( { 'body': fields.SchemalessDictionary( description= 'The body with which the action should respond', ), 'errors': fields.List( fields.Any( fields.ObjectInstance(Error), fields.Dictionary( { 'code': fields.UnicodeString(), 'message': fields.UnicodeString(), 'field': fields.UnicodeString(), 'traceback': fields.UnicodeString(), 'variables': fields.SchemalessDictionary(), 'denied_permissions': fields.List( fields.UnicodeString()), }, ), ), description='The ', ), }, description= 'A dictionary containing either a body dict or an errors list, providing an ' 'instruction on how the stub action should respond to requests', optional_keys=('body', 'errors'), ), ), }, ), } optional_keys = () description = 'The settings for the local transport'
class SettingsFour(SettingsThree): schema = { 'qux': fields.Decimal(), 'new': fields.ByteString(), 'old': fields.UnicodeString(), } # type: SettingsSchema defaults = { 'qux': decimal.Decimal('1.234'), 'old': 'Default old', } # type: SettingsData
class SettingsOneTwoThreeWithOverridesExtended(SettingsOneTwoThreeWithOverrides ): schema = { 'qux': fields.Decimal(), 'new': fields.ByteString(), 'old': fields.UnicodeString(), } # type: SettingsSchema defaults = { 'qux': decimal.Decimal('1.234'), 'old': 'Default old', } # type: SettingsData
class BasicClassSchema(fields.Dictionary): contents = { 'path': fields.UnicodeString(), 'kwargs': fields.SchemalessDictionary(key_type=fields.UnicodeString()), } optional_keys = ['kwargs'] object_type = None def __init__(self, object_type=None, **kwargs): super(BasicClassSchema, self).__init__(**kwargs) if object_type: assert isinstance(object_type, type) self.object_type = object_type def __repr__(self): return '{class_name}({object_type})'.format( class_name=self.__class__.__name__, object_type='object_type={module_name}:{class_name}'.format( module_name=self.object_type.__module__, class_name=self.object_type.__name__, ) if self.object_type else '', )
class TestAction(Action): __test__ = False # So that PyTest doesn't try to collect this and spit out a warning request_schema = fields.Dictionary({ 'string_field': fields.UnicodeString(), }) response_schema = fields.Dictionary({ 'boolean_field': fields.Boolean(), }) _return = None def run(self, request): return self._return
class TestAction(Action): __test__ = False # So that PyTest doesn't try to collect this and spit out a warning request_schema = fields.Dictionary({ 'string_field': fields.UnicodeString(), }) # type: Optional[fields.Dictionary] response_schema = fields.Dictionary({ 'boolean_field': fields.Boolean(), }) # type: Optional[fields.Dictionary] _return = None # type: Optional[Dict[six.text_type, Any]] def run(self, request): return self._return
class HelloAction(Action): request_schema = fields.Dictionary( { 'name': fields.UnicodeString(), 'optional': fields.Integer(), 'errors': fields.Integer() }, optional_keys=('optional', 'errors')) def run(self, request): if request.body.get('errors') == 1: raise ActionError([Error('FOO', 'Foo error')]) if request.body.get('errors') == 2: raise ActionError( [Error('BAZ', 'Baz error'), Error('QUX', 'Qux error')]) return {'salutation': 'Hello, {}'.format(request.body['name'])}