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'])}
