async def do_test(): users = [] users.append( User(id=2, name='test2', num=556789, password='******', sex=2, age=30)) users.append( User(id=3, name='test3', num=556790, password='******', sex=1, age=25)) result = await User.batch_add(users) self.assertEqual(result.affected, 2) query_users = await User.batch_get([1, 2, 3]) self.assertEqual(len(query_users), 3) self.assertEqual(query_users[0].id, 1) self.assertEqual(query_users[1].name, 'test2') self.assertEqual(query_users[2].num, 556790)
def add_users(session): users = [ User(username='******', is_active=True, balance=0), User(username='******', is_active=True), ] session.bulk_save_objects(users, return_defaults=True) return users
def test_flask_context(info): class Request: pass info.path = ['user', 'edges', 0, 'node', 'groups'] info.field_name = 'groups' info.context = Request() get_data_loader = ( NestedFilterableConnectionField._get_or_create_data_loader) model_loader_1 = get_data_loader(User(), info, {'filters': { 'username': '******' }}) assert isinstance(model_loader_1, ModelLoader) model_loader_2 = get_data_loader(User(), info, {'filters': { 'username': '******' }}) assert model_loader_1 is model_loader_2 info.path = ['user', 'edges', 0, 'node', 'anotherGroups'] model_loader_3 = get_data_loader(User(), info, {'filters': { 'username': '******' }}) assert model_loader_1 is not model_loader_3
def test_empty_response(session): session.add(User(username='******', is_active=True, balance=0)) session.add(User(username='******', is_active=True)) session.commit() execution_result = schema.execute( '{field{edges{node{username}}}}', context={'session': session} ) assert not execution_result.errors assert not execution_result.invalid assert execution_result.data assert 'field' in execution_result.data field = execution_result.data['field'] assert 'edges' in field edges = field['edges'] assert len(edges) == 2 node = edges[0]['node'] assert node == {'username': '******'} node = edges[1]['node'] assert node == {'username': '******'}
def test_multiple_accounts_with_same_email(self): user1 = User(username='******') user2 = User(username='******') user1.email = '*****@*****.**' user2.email = '*****@*****.**' self.do_login.when.called_with(after_complete_checks=False)\ .should.throw(AuthException)
async def do_test(): current_count = await User.query(Func.count()).scalar() self.assertEqual(current_count, 3) current_sum = await User.query(Func.sum(User.age)).scalar() self.assertEqual(current_sum, 90) users = [] users.append( User(id=6, name='test6', num=656789, password='******', sex=2, age=60)) users.append( User(id=7, name='test7', num=756790, password='******', sex=1, age=70)) result = await User.batch_add(users) self.assertEqual(result.affected, 2) query = await User.query(User.name, User.num).filter( And(User.sex == 1, User.age < 30)).order_by(User.age, desc=True).first() self.assertIsInstance(query, User) self.assertEqual(query.name, 'test3') self.assertEqual(query.num, 556790) self.assertIsNone(query.age) self.assertIsNone(query.sex) self.assertIsNone(query.id) query = await User.query().filter( And(Or(User.sex == 1, User.age < 45), User.id.in_([3, 4, 5, 6, 7]))).order_by(User.age).all() self.assertEqual(len(query), 3) self.assertIsInstance(query[0], User) self.assertEqual(query[0].age, 25) self.assertEqual(query[1].num, 787878) query = await User.query(User.sex, Func.count()).group_by(User.sex).rows() self.assertEqual(len(query), 2) self.assertEqual(query[0].sex, 1) self.assertEqual(query[0].count, 4)
def test_safe_save_to_database_single(self): uuid = str(uuid4()) user = User(uuid=uuid, email='*****@*****.**') assert safe_save_to_database(user) user = User.get(uuid) assert user.email == '*****@*****.**'
def start_session(username="******", password="******", enterprise="enterprise", api_url="https://*****:*****@enterprse.com" user.enterprise_id = "<enterprise_id>" user.enterprise_name = "enterprise" user.firstname = "John", user.id = "<user_id>" user.lastname = "Doe" user.role = "ROLE" # Set API KEY session._login_controller.api_key = user.api_key with patch.object(NURESTTestSession, "_authenticate", return_value=True): session.start() return user
def test_impersonate(self): """ GET /enterprises with impersonation """ session = start_session() with patch.object(NURESTTestSession, "_authenticate", return_value=True): session.start() session.impersonate(username='******', enterprise='enterprise') mock = MockUtils.create_mock_response(status_code=200, data=[]) user = User() with patch('requests.Session.request', mock): user.enterprises.fetch() headers = MockUtils.get_mock_parameter(mock=mock, name='headers') self.assertIn('X-Nuage-ProxyUser', headers) self.assertEquals(headers['X-Nuage-ProxyUser'], 'johndoe@enterprise') self.assertEquals(session.is_impersonating, True) session.stop_impersonate() self.assertEquals(session.is_impersonating, False) with patch('requests.Session.request', mock): user.enterprises.fetch() headers = MockUtils.get_mock_parameter(mock=mock, name='headers') self.assertNotIn('X-Nuage-ProxyUser', headers)
def test_parent_for_matching_rest_name(self): """ """ enterprise1 = Enterprise(id='4', name='enterprise') user = User() user.parent_object = enterprise1 self.assertEquals(user.parent_for_matching_rest_name(['enterprise']), enterprise1) self.assertIsNone(user.parent_for_matching_rest_name(['not-enterprise']))
def test_model_from_definition(self): self.assertEqual(model_from_definition('tests.models.User'), User) self.assertEqual(model_from_definition(User), User) self.assertRaises(AssertionError, model_from_definition, model_definition='django.test.override_settings') self.assertRaises(AssertionError, model_from_definition, model_definition=User())
def test_safe_save_to_database_multi(self): uuid = str(uuid4()) user = User(uuid=uuid, email='*****@*****.**') t2 = Table2(id=1, user_uuid=uuid) assert safe_save_to_database([user, t2]) user = User.get(uuid) assert user.email == '*****@*****.**' t2 = Table2.get(1) assert t2.user_uuid == uuid
def test_replace_insert(self): uuid = str(uuid4()) user = User(uuid=uuid, email='*****@*****.**') save_to_database(user) user = {'uuid': uuid, 'email': '*****@*****.**'} session = Session() session.execute(User.__table__.insert(mysql_replace_insert=True), user) session.commit() user = User.get(uuid) assert user.email == '*****@*****.**'
def test_fetchers(self): """ test fetchers registry methods """ user = User() rest_names = user.children_rest_names self.assertEquals(rest_names, ['group', 'enterprise']) self.assertEquals(user.fetcher_for_rest_name('group'), []) self.assertEquals(user.fetcher_for_rest_name('enterprise'), []) self.assertEquals(user.fetcher_for_rest_name('nothing'), None)
def test_get_rest_name(self): """ Get user REST name """ session = start_session(username="******", password="******", enterprise="Alcatel", api_url="https://example.com", version="3.0", api_prefix="api") user = User() self.assertEquals(user.rest_name, 'me') self.assertEquals(user.get_resource_url(), 'https://example.com/api/v3_0/me')
def test_data_response_and_filtration(session): session.add(User(username='******', is_active=True, balance=0)) session.add(User(username='******', is_active=True)) session.commit() execution_result = schema.execute( '{field(filters:{username: "******"}){edges{node{username balance}}}}', context={'session': session}, ) assert not execution_result.errors assert not execution_result.invalid assert execution_result.data assert 'field' in execution_result.data field = execution_result.data['field'] assert 'edges' in field edges = field['edges'] assert len(edges) == 1 node = edges[0]['node'] assert node == {'username': '******', 'balance': 0}
def test_model_dataloader_creation(info): info.path = ['user', 'edges', 0, 'node', 'groups'] info.field_name = 'groups' get_data_loader = ( NestedFilterableConnectionField._get_or_create_data_loader) model_loader_1 = get_data_loader(User(), Group, info, {'filters': { 'name': 'group_name' }}) assert isinstance(model_loader_1, ModelLoader) model_loader_2 = get_data_loader(User(), Group, info, {'filters': { 'name': 'group_name' }}) assert model_loader_1 is model_loader_2 info.path = ['user', 'edges', 0, 'node', 'anotherGroups'] model_loader_3 = get_data_loader(User(), Group, info, {'filters': { 'name': 'group_name' }}) assert model_loader_1 is not model_loader_3
def test_contains(self): """ Fetcher contains object """ user = User() group1 = Group(id='xxxx-xxxx-xxx', name="group1") group2 = Group(id='yyyy-yyyy-yyy', name="group2") group3 = Group(id='zzzz-zzzz-zzz', name="group3") user.add_child(group1) user.add_child(group2) self.assertEquals(group1 in user.groups, True) self.assertEquals(group2 in user.groups, True) self.assertEquals(group3 in user.groups, False)
async def do_test(): user_id = await User.add( User(id=4, name='test4', num=556799, password='******', sex=2, age=24)) result = await User.remove(User.num == 556799) self.assertEqual(result.affected, 1) self.assertIsNone(await User.get(user_id)) result = await User.remove( And(User.id.in_([1, 2, 3]), User.sex == 2)) self.assertEqual(result.affected, 1) self.assertIsNone(await User.get(2))
def test_index(self): """ Fetcher index object """ user = User() group1 = Group(id='xxxx-xxxx-xxx', name="group1") group2 = Group(id='yyyy-yyyy-yyy', name="group2") group3 = Group(id='zzzz-zzzz-zzz', name="group3") user.add_child(group1) user.add_child(group2) self.assertEquals(user.groups.index(group1), 0) self.assertEquals(user.groups.index(group2), 1) with self.assertRaises(ValueError): user.groups.index(group3)
def test_flush(self): """ Flush fetcher """ user = User() group1 = Group(name="group1") group2 = Group(name="group2") group3 = Group(name="group3") user.add_child(group1) user.add_child(group2) user.groups.append(group3) self.assertEquals(user.groups, [group1, group2, group3]) user.groups.flush() self.assertEquals(user.groups, [])
def test_to_dict(self): """ Get object as dictionary """ user = User() user.id = 3 user.user_name = "Christophe" user.password = '******' user.api_key = 'ABCD' to_dict = user.to_dict() self.assertEquals(to_dict['userName'], 'Christophe') self.assertEquals(to_dict['password'], 'sorry') self.assertEquals(to_dict['APIKey'], 'ABCD') self.assertEquals(to_dict['parentID'], None) self.assertEquals(to_dict['parentType'], None) self.assertEquals(to_dict['owner'], None) self.assertEquals(to_dict['creationDate'], None)
def test_get_rest_name(self): """ Get user REST name """ session = start_session(username="******", password="******", enterprise="Alcatel", api_url="https://example.com", version="3.0", api_prefix="api") with patch.object(NURESTTestSession, "_authenticate", return_value=True): session.start() user = User() self.assertEquals(user.rest_name, 'me') self.assertEquals(user.get_resource_url(), 'https://example.com/api/v3_0/me')
def test_from_dict(self): """ Fill object from a dictionary """ to_dict = dict() to_dict['ID'] = 3 to_dict['userName'] = '******' to_dict['password'] = '******' to_dict['APIKey'] = '12453' #to_dict['creationDate'] = '2014-04-25 17:05:34' user = User() user.from_dict(to_dict) self.assertEquals(user.id, 3) self.assertEquals(user.user_name, 'Employee') self.assertEquals(user.password, 'anotherPassword') self.assertEquals(user.api_key, '12453') self.assertEquals(user.parent_id, None) self.assertEquals(user.parent_type, None)
def test_distinct_values_of(self): user, new = User.objects.get_or_create(name="Sergio Mena") role_lst = [] with BlockSave(Role): for i in range(1, 6, 1): role = Role(name="Musician%s" % i, usr=user) role.save() role_lst.append(role) user_dict_1 = Role.objects.filter( name="Musician1").distinct_values_of("usr_id") assert sum(user_dict_1.values()) == 1 user_dict_2 = Role.objects.filter( usr_id=user.key).distinct_values_of("usr_id") assert sum(user_dict_2.values()) == 5 Role.objects.filter(active=True).delete() with BlockSave(Role, query_dict={'active': True}): for i, r in enumerate(role_lst): if i == 3: pass else: r.active = True r.save() user_dict_3 = Role.objects.filter( active=True).distinct_values_of("usr_id") assert sum(user_dict_3.values()) == 4 new_user = User(name="Valnetin Hegg") new_user.blocking_save() role_lst[0].usr = new_user role_lst[0].blocking_save(query_dict={'usr': new_user}) user_dict_4 = Role.objects.filter( active=True, usr_id=user.key).distinct_values_of("usr_id") assert sum(user_dict_4.values()) == 3 with BlockDelete(Role): for r in role_lst: r.delete()
async def do_test(): user = User(id=5, name='test5', num=589223, password='******', sex=1, age=45) result = await User.add(user) self.assertEqual(result, 5) self.assertEqual((await User.get(5)).num, 589223) new_num = 787878 update_data = Dict(num=new_num) result = await User.update( update_data, And(User.sex == user.sex, User.age == user.age)) self.assertEqual(result.affected, 1) updated_user = await User.get(5) self.assertEqual(updated_user.num, new_num)
async def do_test(): t_model = TestTypesModel() try: await TestTypesModel.add(t_model) assert False, 'Should be raise a AddEmptyInstanceError' except AddEmptyInstanceError: pass test = 'hehe' t_model.text = test self.assertIsNone(t_model.id) self.assertEqual(await TestTypesModel.add(t_model), 1) self.assertEqual(t_model.id, 1) t_model = await TestTypesModel.get(1) self.assertEqual(t_model.text, test) self.assertEqual(t_model.float_, float(t_model._get_value('float_'))) user = User(name='test1', num=133459, password='******', sex=1, age=20, date=datetime.now()) try: await User.add(user) assert False, 'Should be raise a MissingPKError' except MissingPKError: pass user_id = 1 user.id = user_id self.assertEqual(user.id, user_id) query = await User.get(user_id) self.assertIsNone(query) self.assertEqual(await User.add(user), user_id) query = await User.get(user_id) self.assertEqual(query.id, 1) self.assertEqual(query.num, 133459) self.assertEqual(query.age, 20)
def test_parents_relationship(self): """ Test is parent obects are correctly set""" user = User() group1 = Group(id='xxxx-xxxx-xxx', name="group1") user.add_child(group1) self.assertEquals(group1.parent_object, user) user.remove_child(group1) self.assertEquals(group1.parent_object, None) user.add_child(group1) updated_group = Group(id='xxxx-xxxx-xxx', name="group-updated") user.update_child(updated_group) self.assertEquals(user.groups[0], updated_group) self.assertEquals(user.groups[0].name, 'group-updated') with self.assertRaises(InternalConsitencyError): user.add_child(user)
def start_session(username="******", password="******", enterprise="enterprise", api_url="https://*****:*****@enterprse.com" user.enterprise_id ="<enterprise_id>" user.enterprise_name ="enterprise" user.firstname ="John", user.id ="<user_id>" user.lastname ="Doe" user.role ="ROLE" # Set API KEY session._login_controller.api_key = user.api_key # Activate session _NURESTSessionCurrentContext.session = session return user
async def do_test(): self.assertTrue(await TestTypesModel.show_create()) self.assertTrue(await TestTypesModel.show_struct()) self.assertIsInstance(TestTypesModel.smallint, field.Smallint) self.assertIsInstance(TestTypesModel.key, Key) try: TestTypesModel.new_attr = field.Smallint(3) assert False, 'Should be raise a ModelSetAttrError' except ModelSetAttrError: pass test_value = 'test' t_model = TestTypesModel(string=test_value) self.assertIsInstance(t_model.key, Key) self.assertIsNone(t_model.id) self.assertIsNone(t_model.now) self.assertEqual(t_model.string, test_value) try: t_model.no_has_attr = 1 assert False, 'Should be raise a AttributeError' except AttributeError: pass try: t_model.id = 1 assert False, 'Should be raise a ModifyAutoPkError' except ModifyAutoPkError: pass user_id = 1234457 user = User(id=user_id) self.assertEqual(user.id, user_id) self.assertIsNone(await TestTypesModel.alter()) self.assertTrue(await TestTypesModel.alter( modify_col=[TestTypesModel.string, TestTypesModel.decimal], drop_col=TestTypesModel.now))