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