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