def test_construct_collection(self, mock_constructor):
mock_client = create_mock_object(
ApimasClientAdapter, ['construct_collection', 'ADAPTER_CONF'],
ismagic=True)
mock_client.__class__.__bases__ = (NaiveAdapter, )
mock_instance = {
'*': {
'field1': {
self.adapter_conf: {
'foo': 'bar'
},
'another': {},
},
'field2': {
self.adapter_conf: {
'bar': 'foo'
},
}
}
}
loc = ('api', 'collection', '.collection')
mock_constructor.return_value = mock_instance
instance = mock_client.construct_collection(mock_client,
mock_instance, {},
loc,
context={})
self.assertEqual(len(instance), 2)
instance_conf = instance.get(mock_client.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertEqual(instance_conf['field1'], {'foo': 'bar'})
self.assertEqual(instance_conf['field2'], {'bar': 'foo'})
mock_constructor.assert_called_once
def test_convert(self, mock_json, mock_yaml, mock_super):
mock_cred_obj = create_mock_object(
Credentials, ['convert'], ismagic=True)
mock_cred_obj.fail.side_effect = BadParameter('')
mock_super.convert.return_value = None
mock_json.return_value = self.credentials
mock_yaml.return_value = self.credentials
mock_cred_obj.load_json = mock_json
mock_cred_obj.load_yaml = mock_yaml
mock_cred_obj.file_type = 'ivalid'
self.assertRaises(BadParameter, mock_cred_obj.convert,
mock_cred_obj, '', '', '')
mocks = {
'json': mock_json,
'yaml': mock_yaml,
}
for k, v in mocks.iteritems():
mock_cred_obj.file_type = k
mock_cred_obj.parse_credentials.return_value = ('foo', 'bar')
foo, bar = mock_cred_obj.convert(mock_cred_obj, '', '', '')
self.assertEqual(foo, 'foo')
self.assertEqual(bar, 'bar')
mock_cred_obj.parse_credentials.assert_called_with(v.return_value)
def test_construct_property(self):
mock_properties = {
'foo': 'foo_mapping',
'bar': 'bar_mapping',
}
mock_adapter = create_mock_object(
DjangoRestAdapter, ['construct_property', 'ADAPTER_CONF'])
mock_adapter.PROPERTY_MAPPING = mock_properties
mock_instance = {self.adapter_conf: {}}
self.assertRaises(utils.DRFAdapterException,
mock_adapter.construct_property,
mock_adapter,
instance=mock_instance,
spec={},
loc=(),
context={},
property_name='unknown')
instance = mock_adapter.construct_property(mock_adapter,
instance=mock_instance,
spec={},
loc=(),
context={},
property_name='foo')
self.assertEqual(len(instance), 1)
instance_conf = instance.get(mock_adapter.ADAPTER_CONF)
self.assertEqual(len(instance_conf), 1)
self.assertTrue(instance_conf['foo_mapping'])
def test_construct_property(self):
mock_loc = ('foo', 'bar')
mock_adapter = create_mock_object(
NaiveAdapter, ['construct_property', 'ADAPTER_CONF'])
mock_properties = {'a': 'b'}
mock_adapter.PROPERTY_MAPPING = mock_properties
mock_adapter.SKIP_FIELDS = {'bar'}
mock_instance = {mock_adapter.ADAPTER_CONF: {}}
context = {'constructed': ['foo', 'bar']}
self.assertRaises(ApimasException,
mock_adapter.construct_property, mock_adapter,
instance=mock_instance, spec={}, loc=mock_loc,
context=context, property_name='unknown')
mock_adapter.construct_type.return_value = 'test'
self.assertRaises(doc.DeferConstructor,
mock_adapter.construct_property, mock_adapter,
instance=mock_instance, spec={}, loc=mock_loc,
context=context, property_name='a')
mock_adapter.extract_type.return_value = 'bar'
instance = mock_adapter.construct_property(
mock_adapter, instance=mock_instance, spec={}, loc=mock_loc,
context=context, property_name='a')
self.assertEqual(instance, mock_instance)
mock_adapter.extract_type.return_value = 'foo'
instance = mock_adapter.construct_property(
mock_adapter, instance=mock_instance, spec={}, loc=mock_loc,
context=context, property_name='a')
self.assertEqual(len(instance), 1)
self.assertEqual(instance[mock_adapter.ADAPTER_CONF], {'b': True})
def test_construct_struct_option(self):
mock_cli = create_mock_object(
ApimasCliAdapter, ['construct_struct_option', 'ADAPTER_CONF'])
mock_cli.struct_map = {}
mock_loc = ('foo', 'bar')
mock_instance = {
'.struct': {
'foo': {
self.adapter_conf: {
'foo_option': {
'a': {},
}
}
},
'bar': SKIP,
},
self.adapter_conf: {},
}
parent_name = 'foo'
instance = mock_cli.construct_struct_option(mock_cli,
instance=mock_instance,
parent_name=parent_name,
spec={},
loc=mock_loc,
option_name='test')
self.assertEqual(len(instance), 2)
instance_conf = instance.get(mock_cli.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertEqual(len(instance_conf), 1)
self.assertEqual(instance_conf['test-foo_option'], {'a': {}})
self.assertEqual(mock_cli.struct_map,
{'test-foo_option': ('foo', 'foo_option')})
def test_construct_cli_option(self):
context = {'parent_name': 'foo'}
mock_loc = ('foo', 'bar', '*', 'field', 'type')
mock_cli = create_mock_object(ApimasCliAdapter,
['construct_cli_option', 'ADAPTER_CONF'])
mock_cli.construct_option_type.return_value = 'option type'
self.assertEqual(
mock_cli.construct_cli_option(mock_cli,
instance=SKIP,
spec={},
loc=mock_loc,
context=context), SKIP)
mock_cli.extract_type.assert_not_called
mock_cli.extract_type.return_value = '.struct'
spec = {'option_name': 'my'}
mock_cli.construct_struct_option.return_value = 'struct_option'
instance = mock_cli.construct_cli_option(mock_cli,
instance={},
spec=spec,
loc=mock_loc,
context=context)
self.assertEqual(instance, 'struct_option')
mock_cli.extract_type.assert_called_with({})
mock_cli.construct_struct_option.assert_called_once_with({}, 'foo',
spec,
mock_loc,
'my')
mock_cli.extract_type.return_value = 'foo'
mock_cli.init_adapter_conf.return_value = {
self.adapter_conf: {
'my': {}
}
}
instance = mock_cli.construct_cli_option(mock_cli,
instance={},
spec=spec,
loc=mock_loc,
context=context)
self.assertEqual(instance[self.adapter_conf]['my'],
{'type': 'option type'})
mock_cli.construct_option_type.assert_called_once
mock_cli.init_adapter_conf.return_value = {
self.adapter_conf: {
'my': {}
},
'.required': {}
}
instance = mock_cli.construct_cli_option(mock_cli,
instance={},
spec=spec,
loc=mock_loc,
context=context)
self.assertEqual(instance[self.adapter_conf]['my'], {
'type': 'option type',
'required': True
})
def test_contruct_option_type(self):
mock_cli = create_mock_object(ApimasCliAdapter,
['construct_option_type'])
mock_cli.SKIP_FIELDS = {'foo'}
self.assertIsNone(
mock_cli.construct_option_type(mock_cli,
instance={},
spec={},
loc={},
context={},
predicate_type='foo'))
mock_a = mock.Mock()
mock_a.return_value = 'test'
mock_b = mock.Mock()
type_mapping = {
'a': mock_a,
'b': mock_b,
}
mock_cli.TYPE_MAPPING = type_mapping
option_type = mock_cli.construct_option_type(mock_cli,
instance={},
spec={},
loc={},
context={},
predicate_type='.a')
self.assertEqual(option_type, 'test')
mock_b.assert_not_called
mock_a.assert_called_once_with()
def test_construct_cli_auth(self, mock_option, mock_credentials):
mock_cli = create_mock_object(ApimasCliAdapter,
['construct_cli_auth', 'ADAPTER_CONF'],
ismagic=True)
self.assertRaises(doc.DeferConstructor, mock_cli.construct_cli_auth,
mock_cli, {}, {}, (), {})
mock_option_ret = mock.MagicMock()
mock_option.return_value = mock_option_ret
mock_a = mock.MagicMock()
mock_b = mock.MagicMock()
mock_c = mock.MagicMock()
mock_commands = {'actions': [mock_a, mock_b, mock_c]}
mock_instance = {self.adapter_conf: mock_commands}
mock_schema = {
'a': {
'foo': {}
},
'b': {
'bar': {}
},
}
mock_spec = {'.auth_format': {'format': 'mock_format'}}
mock_spec.update(mock_schema)
mock_cli.get_structural_elements.return_value = ['a', 'b']
mock_cli.construct_cli_auth(mock_cli, mock_instance, mock_spec, (), {})
mock_option.assert_called_once
self.assertEqual(mock_option_ret.call_count, 3)
mock_credentials.assert_called_once_with(schema=mock_schema,
file_type='mock_format')
mock_option.assert_called_once
mock_option_ret.assert_any_call(mock_a)
mock_option_ret.assert_any_call(mock_b)
mock_option_ret.assert_any_call(mock_c)
def test_construct_ref(self, mock_constructor, mock_normalizer):
mock_root_url = 'mock'
mock_client = create_mock_object(ApimasClientAdapter,
['construct_ref', 'ADAPTER_CONF'])
mock_client.__class__.__bases__ = (NaiveAdapter, )
mock_client.root_url = mock_root_url
mock_loc = ('foo', 'bar')
mock_instance = {self.adapter_conf: {}}
mock_constructor.return_value = mock_instance
spec = {'to': 'foo'}
instance = mock_client.construct_ref(mock_client, mock_instance, spec,
mock_loc, {})
self.assertEqual(len(instance), 1)
instance_conf = instance.get(mock_client.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertTrue(isinstance(instance_conf['coerce'], mock.MagicMock))
mock_normalizer.assert_called_once_with(
TRAILING_SLASH.join((mock_root_url, mock_loc[0], 'foo', '')))
spec['many'] = True
instance = mock_client.construct_ref(mock_client, mock_instance, spec,
mock_loc, {})
self.assertEqual(len(instance), 1)
instance_conf = instance.get(mock_client.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertEqual(len(instance_conf), 2)
self.assertEqual(instance_conf['type'], 'list')
self.assertTrue(
isinstance(instance_conf['schema']['coerce'], mock.MagicMock))
mock_normalizer.assert_called_with(
TRAILING_SLASH.join((mock_root_url, mock_loc[0], 'foo', '')))
def test_construct_field(self):
mock_instance = {'foo': {'bar': {}}}
mock_loc = ('foo', 'bar')
mock_client = create_mock_object(ApimasClientAdapter,
['construct_field', 'ADAPTER_CONF'])
mock_client.init_adapter_conf.return_value = mock_instance
mock_client.extract_type.return_value = None
self.assertRaises(ApimasException, mock_client.construct_field,
mock_client, mock_instance, {}, mock_loc, {})
mock_client.extract_type.assert_called_once_with(mock_instance)
nested_structures = {'.struct', '.structarray'}
expected = {'foo'}
mock_client.construct_nested_field.return_value = expected
for structure in nested_structures:
mock_client.extract_type.return_value = structure
instance = mock_client.construct_field(mock_client, mock_instance,
{}, mock_loc, {})
self.assertEqual(instance, expected)
mock_client.construct_nested_field.assert_called
mock_client.init_adapter_conf.assert_called_with(mock_instance)
mock_client.extract_type.assert_called_with(mock_instance)
mock_client.extract_type.return_value = 'foo'
instance = mock_client.construct_field(mock_client, mock_instance, {},
mock_loc, {})
mock_client.init_adapter_conf.assert_called_with(mock_instance)
mock_client.extract_type.assert_called_with(mock_instance)
def test_set_field_context(self):
matches_a = [doc.ANY, 'foo']
matches_b = ['bar']
match_patterns = [matches_a, matches_b]
mock_permission = create_mock_object(
ApimasPermissions, ['set_field_context'])
self.mock_request.parser_context = {}
expected = [doc.ANY, ['bar']]
for i, match_pattern in enumerate(match_patterns):
mock_permission.set_field_context(
mock_permission, self.mock_request, self.mock_view,
match_pattern)
accessible_fields = self.mock_request.parser_context.get(
'accesible_fields')
writable_fields = self.mock_request.parser_context.get(
'writable_fields')
self.assertEqual(writable_fields, expected[i])
self.assertIsNone(accessible_fields)
self.mock_request.parser_context = {}
for action in ['list', 'retrieve']:
self.mock_view.action = action
for i, match_pattern in enumerate(match_patterns):
mock_permission.set_field_context(
mock_permission, self.mock_request, self.mock_view,
match_pattern)
accessible_fields = self.mock_request.parser_context.get(
'accesible_fields')
writable_fields = self.mock_request.parser_context.get(
'writable_fields')
self.assertEqual(accessible_fields, expected[i])
self.assertIsNone(writable_fields)
def test_contruct_drf_collection(self, mock_view_gen):
mock_loc = ('api', 'collection', '.drf_collection')
mock_instance = {
'*': {
'foo': {},
'bar': {},
},
'actions': {
self.adapter_conf: ['a', 'b']
},
self.adapter_conf: {},
}
mock_spec = {
'serializers': ['ser_cls'],
'model_serializers': ['model_ser_cls'],
'model': 'model_cls',
}
mock_adapter = create_mock_object(
DjangoRestAdapter, ['construct_drf_collection', 'ADAPTER_CONF'])
mock_adapter._get_or_import_model.return_value = 'model_imported'
mock_adapter.views = {}
mock_adapter.serializers = {}
mock_adapter.generate_serializer.return_value = 'mock_serializer'
mock_adapter.get_permissions.return_value = 'permissions'
context = {
'constructed': ['.a_constructor'],
'parent_name': 'collection'
}
self.assertRaises(doc.DeferConstructor,
mock_adapter.construct_drf_collection,
mock_adapter,
instance=mock_instance,
spec=mock_spec,
loc=mock_loc,
context=context)
context['constructed'] = ['.collection']
instance = mock_adapter.construct_drf_collection(
mock_adapter,
instance=mock_instance,
spec=mock_spec,
loc=mock_loc,
context=context)
self.assertEqual(len(instance), 3)
self.assertIn('*', instance)
self.assertIn('actions', instance)
instance_conf = instance.get(self.adapter_conf)
self.assertIsNotNone(instance_conf)
self.assertEqual(instance_conf, 'mock_view')
self.assertEqual(mock_adapter.views['collection'], 'mock_view')
self.assertEqual(mock_adapter.serializers['collection'],
'mock_serializer')
mock_adapter._get_or_import_model.assert_called_once_with(
'collection', mock_loc + ('model', ), None)
mock_view_gen.assert_called_once_with('collection',
'mock_serializer',
'model_imported',
actions=['a', 'b'],
permissions='permissions')
def test_construct_action(self, mock_argument, mock_option):
mock_cli = create_mock_object(ApimasCliAdapter,
['construct_action', 'ADAPTER_CONF'])
mock_cli.clients = {}
actions = {'foo'}
mock_loc = ('foo', 'bar', 'actions', 'action')
mock_cli.CRITICAL_ACTIONS = actions
mock_cli.RESOURCE_ACTIONS = actions
mock_command = mock.MagicMock()
mock_command.return_value = 'foo_command'
mock_command2 = mock.MagicMock()
mock_command2.return_value = 'bar_command'
commands = {'foo': mock_command, 'bar': mock_command2}
mock_cli.COMMANDS = commands
mock_instance = {self.adapter_conf: {}}
instance = mock_cli.construct_action(mock_cli,
instance=mock_instance,
spec={},
loc=mock_loc,
context={},
action='bar')
self.assertEqual(len(instance), 1)
instance_conf = instance.get(mock_cli.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertEqual(len(instance_conf), 1)
self.assertEqual(instance_conf['bar'], 'bar_command')
mock_command2.assert_called_once
mock_command.assert_not_called
mock_argument.assert_not_called
mock_option.assert_not_called
mock_a = mock.MagicMock()
mock_a.return_value = 'argument_ret'
mock_b = mock.MagicMock()
mock_b.return_value = 'option_ret'
mock_argument.return_value = mock_a
mock_option.return_value = mock_b
instance = mock_cli.construct_action(mock_cli,
instance=mock_instance,
spec={},
loc=mock_loc,
context={},
action='foo')
self.assertEqual(len(instance), 1)
instance_conf = instance.get(mock_cli.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertEqual(len(instance_conf), 2)
self.assertEqual(instance_conf['foo'], 'option_ret')
mock_argument.assert_called_once
mock_a.assert_called_with('foo_command')
mock_option.assert_called_once
mock_b.assert_called_once_with('argument_ret')
def test_get_client(self):
mock_client = create_mock_object(ApimasClientAdapter, ['get_client'])
mock_client.clients = {}
self.assertRaises(ApimasException, mock_client.get_client, mock_client,
'collection')
mock_clients = {'collection': 'value'}
mock_client.clients = mock_clients
value = mock_client.get_client(mock_client, 'collection')
self.assertEquals(value, mock_clients['collection'])
def test_construct_drf_field(self):
mock_loc = ('api', 'foo', '*', 'field', '.drf_field')
mock_instance = {
'.drf_field': {},
'.foo': {},
}
all_constructors = {'.drf_field', '.foo'}
mock_context = {
'constructed': set(),
'all_constructors': all_constructors
}
mock_adapter = create_mock_object(DjangoRestAdapter,
['construct_drf_field'])
self.assertRaises(doc.DeferConstructor,
mock_adapter.construct_drf_field,
mock_adapter,
instance=mock_instance,
spec={},
loc=mock_loc,
context=mock_context)
mock_context['constructed'] = {'.foo'}
mock_adapter.extract_type.return_value = None
self.assertRaises(utils.DRFAdapterException,
mock_adapter.construct_drf_field,
mock_adapter,
instance=mock_instance,
spec={},
loc=mock_loc,
context=mock_context)
mock_adapter.extract_type.return_value = '.identity'
mock_adapter.construct_identity_field.return_value = 'identity field'
mock_adapter.default_field_constructor.return_value = 'drf field'
instance = mock_adapter.construct_drf_field(mock_adapter,
instance=mock_instance,
spec={},
loc=mock_loc,
context=mock_context)
self.assertEqual(instance, 'identity field')
mock_adapter.construct_identity_field.assert_called_once_with(
mock_instance, {}, mock_loc, mock_context, '.identity')
mock_adapter.default_field_constructor.assert_not_called
mock_adapter.extract_type.return_value = '.foo'
instance = mock_adapter.construct_drf_field(mock_adapter,
instance=mock_instance,
spec={},
loc=mock_loc,
context=mock_context)
self.assertEqual(instance, 'drf field')
mock_adapter.default_field_constructor.assert_called_once_with(
mock_instance, {}, mock_loc, mock_context, '.foo')
def test_construct_nested_field(self):
mock_loc = ('foo', 'bar')
mock_client = create_mock_object(
ApimasClientAdapter, ['construct_nested_field', 'ADAPTER_CONF'])
schema = {
'field1': {
self.adapter_conf: {
'foo': 'bar'
},
'another': {},
},
'field2': {
self.adapter_conf: {
'bar': 'foo'
},
}
}
mock_instance = {'.struct': schema, self.adapter_conf: {}}
instance = mock_client.construct_nested_field(mock_client,
mock_instance, {},
mock_loc, {}, '.struct')
self.assertEqual(len(instance), 2)
instance_conf = instance.get(mock_client.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertEqual(instance_conf['type'], 'dict')
self.assertEqual(instance_conf['schema'], {
'field1': {
'foo': 'bar'
},
'field2': {
'bar': 'foo'
}
})
mock_instance = {'.structarray': schema, self.adapter_conf: {}}
instance = mock_client.construct_nested_field(mock_client,
mock_instance, {},
mock_loc, {},
'.structarray')
self.assertEqual(len(instance), 2)
instance_conf = instance.get(mock_client.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertEqual(instance_conf['type'], 'list')
schema = instance_conf['schema']
self.assertEqual(schema['type'], 'dict')
self.assertEqual(schema['schema'], {
'field1': {
'foo': 'bar'
},
'field2': {
'bar': 'foo'
}
})
def test_construct_command(self, mock_group):
mock_cli = create_mock_object(
ApimasCliAdapter,
['construct_command', 'ADAPTER_CONF', 'OPTION_CONSTRUCTORS'])
mock_loc = ('foo', 'bar')
mock_instance = {
'*': {
'foo': {
self.adapter_conf: {
'foo_option': {
'required': True
}
}
},
'bar': {
self.adapter_conf: {
'bar_option': {
'required': True
}
}
},
'another': SKIP,
}
}
command_name = 'foo'
mock_obj = mock.MagicMock()
mock_obj.return_value = 'test'
mock_group.command.return_value = mock_obj
for action in ['create', 'list', 'update', 'retrieve']:
mock_cli.option_allowed.return_value = action != 'delete'
with mock.patch('click.option') as mock_option:
command = mock_cli.construct_command(mock_cli,
instance=mock_instance,
command_name=command_name,
spec={},
loc=mock_loc,
action=action,
command='foo')
self.assertEqual(command, 'test')
if action == 'create':
self.assertEqual(mock_option.call_count, 2)
mock_option.assert_any_call('--bar_option', required=True)
mock_option.assert_any_call('--foo_option', required=True)
elif action == 'delete':
mock_option.assert_not_called
else:
self.assertEqual(mock_option.call_count, 2)
mock_option.assert_any_call('--bar_option')
mock_option.assert_any_call('--foo_option')
def test_extract_related_model(self):
output = mock.Mock(related_model=None)
mock_meta = mock.Mock()
mock_meta.get_field.return_value = output
mock_model = mock.Mock(_meta=mock_meta)
mock_adapter = create_mock_object(
DjangoRestAdapter, ['extract_related_model', 'ADAPTER_CONF'])
mock_adapter.extract_model.return_value = mock_model
self.assertRaises(utils.DRFAdapterException,
mock_adapter.extract_related_model, mock_adapter,
None, None)
output = mock.Mock(related_model='value')
mock_meta.get_field.return_value = output
output = mock_adapter.extract_related_model(mock_adapter, None, None)
self.assertEqual(output, 'value')
def test_generate_field(self):
mock_a = mock.Mock(return_value='foo_field')
mock_b = mock.Mock(return_value='bar_field')
mock_serializer_mapping = {
'foo': mock_a,
'bar': mock_b,
}
mock_adapter = create_mock_object(
DjangoRestAdapter,
['_generate_field', 'ADAPTER_CONF', 'STRUCTURES'])
mock_adapter.SERILIZERS_TYPE_MAPPING = mock_serializer_mapping
mock_adapter.generate_nested_drf_field.return_value = 'nested_field'
self.assertIn('.struct', mock_adapter.STRUCTURES)
self.assertIn('.structarray', mock_adapter.STRUCTURES)
for predicate_type in ['.struct', '.structarray']:
field = mock_adapter._generate_field(mock_adapter,
instance={},
name=None,
predicate_type=predicate_type,
model=None,
automated=True)
self.assertEqual(field, 'nested_field')
mock_adapter.generate_nested_drf_field.assert_called_with(
{}, None, predicate_type, None, onmodel=True)
predicate_type = '.foo'
mock_adapter.get_default_properties.return_value = {}
self.assertNotIn(predicate_type, mock_adapter.STRUCTURES)
field = mock_adapter._generate_field(mock_adapter,
instance={},
name=None,
predicate_type=predicate_type,
model=None,
automated=False)
self.assertEqual(field, 'foo_field')
mock_a.assert_called_with()
mock_b.assert_not_called
field = mock_adapter._generate_field(mock_adapter,
instance={},
name=None,
predicate_type=predicate_type,
model=None,
automated=True)
self.assertEqual(field, {})
def test_construct_cli_commands(self):
mock_cli = create_mock_object(
ApimasCliAdapter, ['construct_cli_commands', 'ADAPTER_CONF'])
mock_instance = {self.adapter_conf: {'actions': set()}}
mock_context = {'parent_name': 'foo'}
mock_cli.init_adapter_conf.return_value = mock_instance
instance = mock_cli.construct_cli_commands(mock_cli,
instance={},
spec={},
loc=(),
context=mock_context)
self.assertEqual(instance, mock_instance)
mock_cli.init_adapter_conf.assert_called_once_with(
{}, initial={'actions': set()})
initial_instance = {
'actions': {
self.adapter_conf: {
'a': 'foo',
'b': 'bar',
}
}
}
instance_and_conf = dict(mock_instance, **initial_instance)
mock_cli.init_adapter_conf.return_value = instance_and_conf
mock_cli.construct_command.return_value = 'foo_bar'
instance = mock_cli.construct_cli_commands(mock_cli,
instance=initial_instance,
spec={},
loc=(),
context=mock_context)
self.assertEqual(len(instance), 2)
instance_conf = instance.get(mock_cli.ADAPTER_CONF)
self.assertIsNotNone(instance_conf)
self.assertEqual(len(instance_conf), 1)
self.assertEqual(instance_conf['actions'], {'foo_bar'})
mock_cli.init_adapter_conf.assert_called_with(
initial_instance, initial={'actions': set()})
self.assertEqual(mock_cli.construct_command.call_count, 2)
mock_cli.construct_command.assert_any_call(instance_and_conf, 'foo',
{}, (), 'a', 'foo')
mock_cli.construct_command.assert_any_call(instance_and_conf, 'foo',
{}, (), 'b', 'bar')
def test_get_ref_params(self):
mock_instance = {'.ref': {'to': 'foo'}}
top_spec = {'foo': 'bar'}
mock_loc = ('foo', 'bar')
mock_adapter = create_mock_object(DjangoRestAdapter,
['_get_ref_params'])
mock_objects = mock.Mock()
mock_model = mock.Mock(objects=mock_objects)
mock_adapter._get_or_import_model.return_value = mock_model
ref_params = mock_adapter._get_ref_params(mock_adapter,
mock_instance,
loc=mock_loc,
top_spec=top_spec,
automated=True,
field_kwargs={})
self.assertEqual(ref_params, {'view_name': 'foo-detail'})
mock_adapter._get_or_import_model.assert_not_called
field_kwargs = {'read_only': True}
ref_params = mock_adapter._get_ref_params(mock_adapter,
mock_instance,
loc=mock_loc,
top_spec=top_spec,
automated=False,
field_kwargs=field_kwargs)
self.assertEqual(ref_params, {
'view_name': 'foo-detail',
'many': False
})
mock_adapter._get_or_import_model.assert_not_called
field_kwargs = {'read_only': False}
mock_instance['.ref'].update({'many': True})
ref_params = mock_adapter._get_ref_params(mock_adapter,
mock_instance,
loc=mock_loc,
top_spec=top_spec,
automated=False,
field_kwargs=field_kwargs)
self.assertEqual(len(ref_params), 3)
self.assertEqual(ref_params['view_name'], 'foo-detail')
self.assertTrue(ref_params['many'])
self.assertTrue(isinstance(ref_params['queryset'], mock.Mock))
mock_adapter._get_or_import_model.assert_called_once_with(
'foo', ('foo', '.drf_collection', 'model'), top_spec)
def test_validate_ref(self, mock_attr, mock_ref):
mock_adapter = create_mock_object(DjangoRestAdapter, ['validate_ref'])
mock_meta = mock.Mock()
mock_model = mock.Mock(_meta=mock_meta)
mock_adapter.extract_model.return_value = mock_model
mock_instance = {'.ref': {'to': 'foo_ref'}}
# Case A: `_validate_relational_field` is passed.
ref_model = mock.Mock()
mock_adapter._get_or_import_model.return_value = ref_model
mock_ref.return_value = '_validate_relational_field_called'
field, model, automated = mock_adapter.validate_ref(
mock_adapter,
instance=mock_instance,
name='foo',
loc=self.loc,
top_spec={},
source='source')
self.assertEqual(field, '_validate_relational_field_called')
self.assertEqual(model, mock_model)
self.assertTrue(automated)
mock_attr.assert_not_called
mock_ref.assert_called_once_with('foo', ref_model, mock.ANY)
mock_meta.get_field.assert_called_once_with('source')
mock_adapter._get_or_import_model.assert_called_once_with(
'foo_ref', self.loc[:1] + ('foo_ref', '.drf_collection', 'model'),
{})
# Case B: `_meta.get_field fails, and `_validate_model_attribute` is
# called`.
mock_meta.get_field.side_effect = FieldDoesNotExist()
mock_attr.return_value = '_validate_model_attribute_called'
field, model, automated = mock_adapter.validate_ref(
mock_adapter,
instance=mock_instance,
name='foo',
loc=self.loc,
top_spec={},
source='source')
self.assertEqual(field, '_validate_model_attribute_called')
self.assertEqual(model, mock_model)
self.assertFalse(automated)
mock_attr.assert_called_once_with('foo', mock_model, 'source')
mock_meta.get_field.assert_called_with('source')
self.assertEqual(mock_meta.get_field.call_count, 2)
def test_has_permission(self):
lookup_field = 'foo'
kwargs = {'foo': 'bar'}
mock_permissions = create_mock_object(
ApimasPermissions, ['has_permission'])
self.mock_view.lookup_field = lookup_field
self.mock_view.kwargs = kwargs
self.assertTrue(mock_permissions.has_permission(
mock_permissions, self.mock_request, self.mock_view))
mock_permissions.isallowed.assert_not_called
self.mock_view.kwargs = {}
output = mock_permissions.has_permission(
mock_permissions, self.mock_request, self.mock_view)
self.assertTrue(isinstance(output, mock.Mock))
mock_permissions.isallowed.assert_called_once_with(
self.mock_request, self.mock_view)
def test_isallowed(self):
mock_tabmatch = mock.Mock(spec=Tabmatch)
mock_tabmatch.multimatch.return_value = []
mock_permissions = create_mock_object(
ApimasPermissions, ['isallowed'])
mock_permissions.permissions = mock_tabmatch
pattern_set = [['foo'], ['bar'], [doc.ANY], [doc.ANY]]
mock_permissions.get_pattern_sets.return_value = pattern_set
# Case A: No matches.
allowed = mock_permissions.isallowed(
mock_permissions, self.mock_request, self.mock_view, obj=None)
self.assertFalse(allowed)
mock_permissions.check_field_conditions.assert_not_called
# Case B: There are matches, but invalid states.
matches = [mock.Mock(field=doc.ANY, state='bar'),
mock.Mock(field='foo', state='foo')]
mock_tabmatch.multimatch.return_value = matches
mock_states = {
'foo': False,
'bar': False,
}
mock_permissions.check_state_conditions.return_value = mock_states
allowed = mock_permissions.isallowed(
mock_permissions, self.mock_request, self.mock_view, obj=None)
self.assertFalse(allowed)
mock_permissions.check_state_conditions.assert_called_once_with(
self.mock_request, self.mock_view, matches, None)
# Case C: There are some states which are valid.
mock_states = {
'foo': True,
'bar': False,
}
mock_permissions.check_state_conditions.return_value = mock_states
allowed = mock_permissions.isallowed(
mock_permissions, self.mock_request, self.mock_view, obj=None)
self.assertTrue(allowed)
mock_permissions.check_state_conditions.assert_called_with(
self.mock_request, self.mock_view, matches, None)
mock_permissions.check_field_conditions.assert_called_once_with(
self.mock_request, self.mock_view, matches[1:])
def test_check_state_conditions(self):
mock_model = mock.MagicMock()
mock_model.collection_foo.return_value = False
mock_model.object_foo.return_value = False
matches = [mock.Mock(state='foo'), mock.Mock(state='foo')]
mock_permission = create_mock_object(
ApimasPermissions, ['check_state_conditions'])
mock_permission.COLLECTION_CHECK_PREFIX = 'collection'
mock_permission.OBJECT_CHECK_PREFIX = 'object'
mock_permission.model = mock_model
self.assertEqual(mock_permission.check_state_conditions(
mock_permission, self.mock_request, self.mock_view,
matches, obj=None), {'foo': False})
mock_model.collection_foo.assert_called_once
matches = [mock.Mock(state=doc.ANY), mock.Mock(state='foo')]
self.assertEqual(mock_permission.check_state_conditions(
mock_permission, self.mock_request, self.mock_view,
matches, obj=None), {doc.ANY: True, 'foo': False})
mock_row = mock.Mock(state='foo')
matches = [mock_row]
for ret in [True, False]:
for obj in [None, 'test']:
if obj is None:
mock_model.collection_foo.return_value = ret
else:
mock_model.object_foo.return_value = ret
states = mock_permission.check_state_conditions(
mock_permission, self.mock_request, self.mock_view,
matches, obj)
self.assertEqual(states, {'foo': ret})
if obj is None:
mock_model.collection_foo.assert_called_with(
row=mock_row, request=self.mock_request,
view=self.mock_view)
else:
mock_model.object_foo.assert_called_with(
obj, row=mock_row, request=self.mock_request,
view=self.mock_view)
def test_partial_validate_sub(self):
mock_client = create_mock_object(ApimasClient, ['_validate_subdata'])
nested_schema = {
'type': 'dict',
'schema': {
'field2': {
'type': 'string',
'required': True,
},
'field3': {
'type': 'string',
'required': True,
}
}
}
validation_schema = {
'field': {
'type': 'list',
'schema': nested_schema
},
'field2': {
'type': 'list',
'schema': nested_schema,
}
}
sub = {'field1': 'foo'}
data = {'unknown': [sub]}
self.assertRaises(ApimasClientException, mock_client._validate_subdata,
mock_client, data, validation_schema, False)
mock_client.partial_validate.assert_not_called
data = {'field': [sub], 'field2': [sub]}
mock_client.partial_validate.return_value = sub
validated = mock_client._validate_subdata(mock_client,
data,
validation_schema,
raise_exception=False)
self.assertEquals(validated, {('field', ): [sub], ('field2', ): [sub]})
mock_client.partial_validate.assert_called
def test_construct_ref(self):
mock_adapter = create_mock_object(
NaiveAdapter, ['construct_ref'])
mock_instance = {'a': {}, 'b': {}}
top_spec = {'api': {'foo': {}, 'bar': {}}}
context = {'top_spec': top_spec}
spec = {'to': 'unknown'}
mock_loc = ('api', 'bar')
self.assertRaises(ApimasException, mock_adapter.construct_ref,
mock_adapter, instance=mock_instance, spec={},
loc=mock_loc, context=context)
mock_adapter.construct_type.assert_not_called
self.assertRaises(ApimasException, mock_adapter.construct_ref,
mock_adapter, instance=mock_instance, spec=spec,
loc=mock_loc, context=context)
mock_adapter.construct_type.assert_not_called
spec['to'] = 'foo'
mock_adapter.construct_ref(mock_adapter, instance=mock_instance,
spec=spec, loc=mock_loc, context=context)
mock_adapter.construct_type.assert_called_once_with(
mock_instance, spec, mock_loc, context, 'ref')
def test_get_pattern_sets(self):
mock_user = mock.MagicMock(spec=AnonymousUser)
mock_permission = create_mock_object(
ApimasPermissions, ['get_pattern_sets', 'ANONYMOUS_ROLES'])
self.mock_request.user = mock_user
pattern_set = mock_permission.get_pattern_sets(
mock_permission, self.mock_request, self.mock_view)
self.assertEqual(len(pattern_set), 4)
self.assertEqual(pattern_set[0], ['mock'])
self.assertEqual(pattern_set[1], mock_permission.ANONYMOUS_ROLES)
self.assertEqual(pattern_set[2], [doc.ANY])
self.assertEqual(pattern_set[3], [doc.ANY])
mock_user = mock.MagicMock()
mock_user.apimas_roles = ['my roles']
self.mock_request.user = mock_user
pattern_set = mock_permission.get_pattern_sets(
mock_permission, self.mock_request, self.mock_view)
self.assertEqual(len(pattern_set), 4)
self.assertEqual(pattern_set[0], ['mock'])
self.assertEqual(pattern_set[1], ['my roles'])
self.assertEqual(pattern_set[2], [doc.ANY])
self.assertEqual(pattern_set[3], [doc.ANY])
def test_allowed_fields(self):
matches = [mock.Mock(field=doc.ANY), mock.Mock(field='b/c')]
data = {
'a': 1,
'b': {
'foo': {
'bar': 1
},
'c': 1,
}
}
self.mock_request.data = data
mock_permission = create_mock_object(
ApimasPermissions, ['allowed_fields'])
allowed_fields = mock_permission.allowed_fields(
mock_permission, self.mock_request, self.mock_view, matches)
self.assertEqual(allowed_fields, {'b/c', doc.ANY})
for action in ['list', 'retrieve']:
self.mock_view.action = action
allowed_fields = mock_permission.allowed_fields(
mock_permission, self.mock_request, self.mock_view, matches)
self.assertEqual(allowed_fields, {'b/c', doc.ANY})
def test_validate_model_field(self, mock_attr, mock_type):
mock_adapter = create_mock_object(
DjangoRestAdapter, ['validate_model_field', 'ADAPTER_CONF'])
field_type = 'foo'
mock_adapter.extract_model.return_value = None
mock_meta = mock.Mock()
mock_model = mock.Mock(_meta=mock_meta)
# Case A: Extracted model is `None`.
self.assertRaises(utils.DRFAdapterException,
mock_adapter.validate_model_field, mock_adapter,
None, 'foo', self.loc, field_type, None)
mock_attr.assert_not_called
mock_type.assert_not_called
# Case B: `_validate_model_type` pass
mock_type.return_value = '_validate_model_type_called'
mock_adapter.extract_model.return_value = mock_model
field, model, automated = mock_adapter.validate_model_field(
mock_adapter, None, 'foo', self.loc, field_type, None)
self.assertEqual(field, '_validate_model_type_called')
self.assertEqual(model, mock_model)
self.assertTrue(automated)
mock_type.assert_called_once_with('foo', mock.ANY, field_type)
mock_attr.assert_not_called
# Case C: `_validate_model_type` fails and `_validate_model_attribute`
# is called.
mock_meta.get_field.side_effect = FieldDoesNotExist()
mock_attr.return_value = '_validate_model_attribute_called'
field, model, automated = mock_adapter.validate_model_field(
mock_adapter, None, 'foo', self.loc, field_type, source='source')
self.assertEqual(field, '_validate_model_attribute_called')
self.assertEqual(model, mock_model)
self.assertFalse(automated)
mock_attr.assert_called_once_with('foo', mock_model, 'source')
mock_meta.get_field.assert_called_with('source')
