def test_create_complete(self):
"""Check Geokret: POST request full informations"""
with app.test_request_context():
admin = mixer.blend(User)
with mixer.ctx(commit=False):
akret = mixer.blend(Geokret)
payload = {
"data": {
"type": "geokret",
"attributes": {
"name": akret.name,
"description": akret.description,
}
}
}
response = self._send_post("/v1/geokrety",
payload=payload,
code=201,
user=admin)
self._check_geokret(response['data'],
akret,
skip_check=['times', 'tracking-code'],
with_private=True)
geokrety = Geokret.query.all()
self.assertEqual(len(geokrety), 1)
geokret = geokrety[0]
self.assertEqual(akret.name, geokret.name)
self._check_geokret(response['data'], geokret, with_private=True)
def _blend(self):
"""Create mocked Moves"""
self.geokret = self.blend_geokret(
created_on_datetime='2018-12-27T23:20:18')
self.move_1 = mixer.blend(Move,
type=MOVE_TYPE_DIPPED,
geokret=self.geokret,
moved_on_datetime="2018-12-27T23:38:33",
latitude=43.704233,
longitude=6.869833)
self.move_2 = mixer.blend(Move,
type=MOVE_TYPE_DIPPED,
geokret=self.geokret,
moved_on_datetime="2018-12-27T23:39:06",
latitude=43.6792,
longitude=6.852933)
self.move_3 = mixer.blend(Move,
type=MOVE_TYPE_DIPPED,
geokret=self.geokret,
moved_on_datetime="2018-12-27T23:41:29",
latitude=43.701767,
longitude=6.84085)
self.move_4 = mixer.blend(Move,
type=MOVE_TYPE_DIPPED,
geokret=self.geokret,
moved_on_datetime="2018-12-27T23:42:15",
latitude=43.693633,
longitude=6.860933)
update_move_distances(db.session, self.geokret.id)
def generate_test_data(self):
with self.app.app_context():
organization = mixer.blend(Organization,
name=mixer.RANDOM,
address='POINT(49.836134 24.023151)')
db.session.add(organization)
user = mixer.blend(User,
fb_first_name=mixer.RANDOM,
fb_last_name=mixer.RANDOM,
fb_id=mixer.RANDOM,
email=mixer.RANDOM,
about_me=mixer.RANDOM)
user = User(user.fb_first_name, user.fb_last_name, user.fb_id,
user.email, user.about_me)
user.organizations.append(organization)
db.session.add(user)
db.session.commit()
issue = mixer.blend(Issue,
reporter='1',
description=mixer.RANDOM,
coordinates='POINT(49.839357 24.028398)')
db.session.add(issue)
comment = mixer.blend(Comment,
author=user,
issue=issue,
message=mixer.RANDOM)
db.session.add(comment)
photo = mixer.blend(Photo,
issue=issue,
file_path=mixer.RANDOM)
db.session.add(photo)
db.session.commit()
def test_get_quote_from_person(client, session):
person = mixer.blend(Person)
expected_quote = mixer.blend(Quote, person=person)
actual_quote = get_quote_from_person(person.slack_user_id,
expected_quote.id)
assert actual_quote == expected_quote
def generate(authors_count: int = 9, books_count: int = 99):
authors = list(
mixer.blend(Author, name=mixer.faker.name())
for _ in range(authors_count))
list(
mixer.blend(
Book, title=mixer.faker.title(), author=random.choice(authors))
for _ in range(books_count))
def test_user_name_uniqueness_taken(self):
"""Check Form User: User name uniqueness - Detect username already taken"""
with app.test_request_context():
with self.assertRaises(UnprocessableEntity):
mixer.init_app(app)
mixer.blend(User, name="someone")
UserSchema.validate_username_uniqueness(
UserSchema(), "someone")
def test_validate_email_uniqueness_taken(self):
"""Check Form User: User email uniqueness - Detect email already taken"""
with app.test_request_context():
with self.assertRaises(UnprocessableEntity):
mixer.init_app(app)
mixer.blend(User, email="*****@*****.**")
UserSchema.validate_email_uniqueness(UserSchema(),
"*****@*****.**")
def blend(self, *args, **kwargs):
move = kwargs.get('move')
if move is None:
with mixer.ctx():
move = mixer.blend('geokrety_api_models.Move')
with mixer.ctx(commit=False):
move_comment = mixer.blend('geokrety_api_models.MoveComment',
type=MOVE_COMMENT_TYPE_COMMENT,
move=move)
self.set_obj(move_comment)
return self
def _blend_users(self):
"""Create mocked User/News/NewsComments"""
mixer.init_app(app)
with mixer.ctx(commit=False):
self.admin = mixer.blend(User)
self.user1 = mixer.blend(User)
self.user2 = mixer.blend(User)
db.session.add(self.admin)
db.session.add(self.user1)
db.session.add(self.user2)
db.session.commit()
def _blend(self):
"""Create mocked User/News/NewsComments"""
with mixer.ctx(commit=False):
self.news1 = mixer.blend(News, author=self.user1)
self.orphan_news = mixer.blend(News, author=None)
self.newscomment1 = mixer.blend(NewsComment, author=self.user1, news=self.news1)
self.newscomment2 = mixer.blend(NewsComment, author=self.user2, news=self.news1)
db.session.add(self.news1)
db.session.add(self.orphan_news)
db.session.add(self.newscomment1)
db.session.add(self.newscomment2)
db.session.commit()
def setup():
role = Role.first(name='user') #Get the 'user' role or create it
if not role:
role = Role.create(name='user', description='provides basic system access', bitmask=2)
if not User.first(email="*****@*****.**"):
mixer.blend('app.models.users.User', email="*****@*****.**", password=encrypt_password('hello'),
confirmed_at=datetime.now(), roles=[role])
if not User.first(email="*****@*****.**"):
mixer.blend('app.models.users.User', email="*****@*****.**", password=encrypt_password('world'),
roles=[role])
def test_audit_item_method_disabled(self):
mixer.init_app(self.app)
mixer.blend(ItemAuditScore, technology='test_index', method='check_test (AuditorTestObj)',
score=0, disabled=True)
auditor = AuditorTestObj(accounts=['test_account'])
item = ChangeItem(index='test_index',
account='test_account', name='item_name')
self.assertEquals(len(item.audit_issues), 0)
auditor.items = [item]
auditor.audit_objects()
self.assertEquals(len(item.audit_issues), 0)
def test_create_user(self):
"""Check User: POST and Read back an user"""
with app.test_request_context():
mixer.init_app(app)
admin = mixer.blend(User)
someone = mixer.blend(User)
with mixer.ctx(commit=False):
user1 = mixer.blend(User)
# Test inserting first user
payload = {
"data": {
"type": "user",
"attributes": {
"name": user1.name,
"password": user1.password,
"email": user1.email
}
}
}
response = self._send_post('/v1/users', payload=payload, code=201)
self._check_user_with_private(response,
user1,
skip_check=['times'])
user1.id = response['data']['id']
response = self._send_get('/v1/users/%s' % user1.id, code=200)
self._check_user_without_private(response,
user1,
skip_check=['times'])
response = self._send_get('/v1/users/%s' % user1.id,
code=200,
user=user1)
self._check_user_with_private(response,
user1,
skip_check=['times'])
response = self._send_get('/v1/users/%s' % user1.id,
code=200,
user=admin)
self._check_user_with_private(response,
user1,
skip_check=['times'])
response = self._send_get('/v1/users/%s' % user1.id,
code=200,
user=someone)
self._check_user_without_private(response,
user1,
skip_check=['times'])
def test_converse_responds_with_two_quotes_per_person(client, session, mock_bot):
mock_person1 = mixer.blend(Person, first_name="Beth")
mock_person2 = mixer.blend(Person, first_name="Valisy")
mock_quotes1 = mixer.cycle().blend(Quote, person=mock_person1)
mock_quotes2 = mixer.cycle().blend(Quote, person=mock_person2)
session.bulk_save_objects([mock_person1, mock_person2, *mock_quotes1, *mock_quotes2])
session.commit()
result = mock_bot.converse([mock_person1.slack_user_id, mock_person2.slack_user_id])
message = result.message
assert message.count("Beth:") == 2
assert message.count("Valisy:") == 2
def test_converse_repeats_quote_if_person_has_fewer_than_two_quotes(client, session, mock_bot):
mock_person1 = mixer.blend(Person, first_name="Beth")
mock_person2 = mixer.blend(Person, first_name="Vasily")
mock_quotes1 = mixer.cycle().blend(Quote, person=mock_person1)
mock_quotes2 = [Quote(content="I only have one quote", person_id=mock_person2.id)]
session.bulk_save_objects([mock_person1, mock_person2, *mock_quotes1, *mock_quotes2])
session.commit()
result = mock_bot.converse([mock_person1.slack_user_id, mock_person2.slack_user_id])
message = result.message
assert message.count("Beth:") == 2
assert message.count("Vasily:") == 2
def _blend_users(self):
"""Create mocked Users"""
mixer.init_app(app)
with mixer.ctx(commit=False):
self.admin = mixer.blend(User, username="******")
self.user1 = mixer.blend(User, username="******")
self.user2 = mixer.blend(User, username="******")
self.user3 = mixer.blend(User, username="******")
self.user4 = mixer.blend(User, username="******")
db.session.add(self.admin)
db.session.add(self.user1)
db.session.add(self.user2)
db.session.add(self.user3)
db.session.add(self.user4)
db.session.commit()
def _blend(self):
"""Create mocked User"""
mixer.init_app(app)
with mixer.ctx(commit=False):
self.admin = mixer.blend(User)
self.user1 = mixer.blend(User)
self.user2 = mixer.blend(User)
self.geokret1 = mixer.blend(Geokret, type="0")
self.geokret2 = mixer.blend(Geokret, type="3")
db.session.add(self.admin)
db.session.add(self.user1)
db.session.add(self.user2)
db.session.add(self.geokret1)
db.session.add(self.geokret2)
db.session.commit()
def test_create_geokret_verify_tracking_code(self):
""" Check Geokret: VERIFY tracking_code"""
with app.test_request_context():
geokret1 = mixer.blend(Geokret)
geokret2 = mixer.blend(Geokret)
geokret3 = mixer.blend(Geokret)
self.assertNotEqual(geokret1.tracking_code, geokret2.tracking_code)
self.assertNotEqual(geokret1.tracking_code, geokret3.tracking_code)
self.assertIsNotNone(geokret1.tracking_code)
self.assertIsNotNone(geokret2.tracking_code)
self.assertIsNotNone(geokret3.tracking_code)
self.assertGreaterEqual(len(geokret1.tracking_code), 6)
self.assertGreaterEqual(len(geokret2.tracking_code), 6)
self.assertGreaterEqual(len(geokret3.tracking_code), 6)
def test_remind_pings_multiple_targes(client, session, mock_bot):
mock_nostalgia_person = mixer.blend(Person)
mock_target_persons = mixer.cycle(3).blend(Person)
mock_quote = mixer.blend(Quote, person=mock_nostalgia_person)
target_user_ids = [target.slack_user_id for target in mock_target_persons]
expected_message = (
f"{' '.join(f'<@{user_id}>' for user_id in target_user_ids)} Do you remember this?"
f'\n\n"{mock_quote.content}" - {mock_nostalgia_person.first_name}'
)
session.bulk_save_objects([mock_nostalgia_person, *mock_target_persons, mock_quote])
session.commit()
result = mock_bot.remind(mock_nostalgia_person.slack_user_id, target_user_ids)
assert expected_message == result.message
def test_get_all_quotes_from_person(num_quotes, client, session):
person = mixer.blend(Person)
expected_quotes = mixer.cycle(num_quotes).blend(Quote, person=person)
actual_quotes = get_all_quotes_from_person(person.slack_user_id)
assert actual_quotes == expected_quotes
def test_safe_query(self):
"""Check DBHelper: safe query"""
with app.test_request_context():
mixer.init_app(app)
user = mixer.blend(User)
obj = safe_query(db, User, 'id', user.id, 'user_id')
self.assertEqual(obj.name, user.name)
def test_get_count(self):
"""Check DBHelper: get count"""
with app.test_request_context():
with mixer.ctx(commit=False):
user = mixer.blend(User)
save_to_db(user)
self.assertEqual(get_count(User.query), 1)
def generate_fake(cls):
"""
:rtype User
"""
from faker import Factory
from mixer.backend.flask import mixer
mixer.faker.locale = 'fa'
faker = Factory.create('fa_IR')
fake = mixer.blend(cls)
fake.real_name = faker.name()
faker = Factory.create()
while True:
try:
fake_username = faker.domain_word()
fake.user_name = fake_username
db.session.add(fake)
db.session.commit()
break
except:
db.session.rollback()
return fake
def blend_geokret(self, *args, **kwargs):
with mixer.ctx():
if 'created_on_datetime' not in kwargs:
kwargs['created_on_datetime'] = "2019-01-12T16:33:46"
if kwargs.get('count'):
return mixer.cycle(kwargs.get('count')).blend(Geokret, **kwargs)
return mixer.blend(Geokret, **kwargs)
def test_create_minimal(self):
"""Check User: POST request minimal informations"""
with app.test_request_context():
with mixer.ctx(commit=False):
someone = mixer.blend(User)
payload = {
"data": {
"type": "user",
"attributes": {
"name": someone.name,
"password": someone.password,
"email": someone.email
}
}
}
response = self._send_post("/v1/users", payload=payload, code=201)
self._check_user_with_private(response,
someone,
skip_check=['times'])
users = User.query.all()
self.assertEqual(len(users), 1)
user = users[0]
self.assertEqual(someone.name, user.name)
self._check_user_with_private(response, user)
def test_create_complete(self):
"""Check User: POST request full informations"""
with app.test_request_context():
with mixer.ctx(commit=False):
someone = mixer.blend(User)
payload = {
"data": {
"type": "user",
"attributes": {
"name": someone.name,
"password": someone.password,
"email": someone.email,
"hour": someone.hour,
"latitude": someone.latitude,
"longitude": someone.longitude,
"observation-radius": someone.observation_radius,
"secid": someone.secid,
"statpic-id": someone.statpic_id
}
}
}
response = self._send_post("/v1/users", payload=payload, code=201)
self._check_user_with_private(response,
someone,
skip_check=['times'])
users = User.query.all()
self.assertEqual(len(users), 1)
user = users[0]
self.assertEqual(someone.name, user.name)
self._check_user_with_private(response, user)
def test_jwt_and_auth_test(self):
# 토큰없이 시도를 할때에는 401 에러는 받습니다.
res = self.client.get(
"/protected",
content_type="application/x-www-form-urlencoded")
assert res.status_code == 401
# Fake User을 만들어서, 해당 유저의 토큰을 발급받습니다.
u = mixer.blend(User)
data = json.dumps({"username": u.username, "password": u.password})
res = self.client.post(
"/auth",
data=data,
content_type="application/json"
)
# 정상적인경우 status 200을 받습니다.
assert res.status_code == 200
assert 'access_token' in str(res.data)
# 이제 헤더에 토큰을 추가해서 다시 시도합니다.
token = json.loads(res.data)["access_token"]
res = self.client.get(
"/",
headers={'Authorization': 'JWT ' + token})
assert res.status_code == 200
def blend_move(self, *args, **kwargs):
with mixer.ctx():
if 'geokret' not in kwargs:
kwargs['geokret'] = mixer.blend(Geokret, created_on_datetime="2019-01-12T16:33:46")
if kwargs.get('count'):
last_date = kwargs['geokret'].created_on_datetime
moves = []
for _ in range(kwargs.get('count')):
last_date = last_date + timedelta(seconds=1)
move = mixer.blend(Move, moved_on_datetime=last_date, **kwargs)
update_geokret_and_moves(db.session, move.geokret_id, move.id)
moves.append(move)
return moves
move = mixer.blend(Move, **kwargs)
update_geokret_and_moves(db.session, move.geokret_id, move.id)
return move
def test_audit_item_method_score_override(self):
mixer.init_app(self.app)
mixer.blend(ItemAuditScore, technology='test_index', method='check_test (AuditorTestObj)',
score=5, disabled=False)
test_account_type = mixer.blend(AccountType, name='AWS')
test_account = mixer.blend(Account, name='test_account', account_type=test_account_type)
item = ChangeItem(index='test_index',
account=test_account.name, name='item_name')
auditor = AuditorTestObj(accounts=[test_account.name])
self.assertEquals(len(item.audit_issues), 0)
auditor.items = [item]
auditor.audit_objects()
self.assertEquals(len(item.audit_issues), 1)
self.assertEquals(item.audit_issues[0].issue, 'Test issue')
self.assertEquals(item.audit_issues[0].score, 5)
def test_remind_gets_a_random_quote_for_person(client, session, mock_bot):
mock_nostalgia_person = mixer.blend(Person)
mock_target_person = mixer.blend(Person)
mock_quote = mixer.blend(Quote, person=mock_nostalgia_person)
expected_message = (
f"<@{mock_target_person.slack_user_id}> Do you remember this?"
f'\n\n"{mock_quote.content}" - {mock_nostalgia_person.first_name}'
)
session.bulk_save_objects([mock_nostalgia_person, mock_target_person, mock_quote])
session.commit()
result = mock_bot.remind(
mock_nostalgia_person.slack_user_id, [mock_target_person.slack_user_id]
)
assert expected_message == result.message
def test_get_random_quotes_from_person_defaults_to_one(client, session):
person = mixer.blend(Person)
expected_quotes = mixer.cycle().blend(Quote, person=person)
random_quotes = get_random_quotes_from_person(person.slack_user_id)
assert set(random_quotes).issubset(expected_quotes)
assert len(random_quotes) == 1
def test_create_geokret(self):
""" Check Geokret: POST and Read back a geokret"""
with app.test_request_context():
mixer.init_app(app)
admin = mixer.blend(User)
someone = mixer.blend(User)
with mixer.ctx(commit=False):
akret = mixer.blend(Geokret)
# Test inserting first user
payload = {
"data": {
"type": "geokret",
"attributes": {
"name": akret.name,
"description": akret.description,
}
}
}
response = self._send_post('/v1/geokrety',
payload=payload,
code=201,
user=admin)
self._check_geokret(response['data'],
akret,
skip_check=['times', 'tracking-code'],
with_private=True)
akret.id = response['data']['id']
akret.tracking_code = response['data']['attributes'][
'tracking-code']
response = self._send_get('/v1/geokrety/%s' % akret.id, code=200)
self._check_geokret(response['data'], akret, skip_check=['times'])
response = self._send_get('/v1/geokrety/%s' % akret.id,
code=200,
user=someone)
self._check_geokret(response['data'], akret, skip_check=['times'])
response = self._send_get('/v1/geokrety/%s' % akret.id,
code=200,
user=admin)
self._check_geokret(response['data'],
akret,
skip_check=['times'],
with_private=True)
def ensure_personas():
return {
'malcolm': mixer.blend('beavy.models.user.User',
name="Malcolm Reynolds",
password=encrypt_password('password'),
active=True,
confirmed_at=datetime.now()),
'zoe': mixer.blend('beavy.models.user.User',
name="Zoe Washburne",
password=encrypt_password('password'),
active=True,
confirmed_at=datetime.now()),
'inara': mixer.blend('beavy.models.user.User',
name="Inara Serra",
password=encrypt_password('password'),
active=True,
confirmed_at=datetime.now())
}
def generate_test_data():
with app.app_context():
user = mixer.blend(User,
fb_first_name=mixer.RANDOM,
fb_last_name=mixer.RANDOM,
fb_id=mixer.RANDOM,
email=mixer.RANDOM)
db.session.add(user)
db.session.commit()
def test_save_issues(self):
mixer.init_app(self.app)
test_account = mixer.blend(Account, name='test_account')
technology = mixer.blend(Technology, name='testtech')
item = Item(region="us-west-2", name="testitem", technology=technology, account=test_account)
revision = mixer.blend(ItemRevision, item=item, config={}, active=True)
item.latest_revision_id = revision.id
mixer.blend(ItemAudit, item=item, issue='test issue')
auditor = Auditor(accounts=[test_account.name])
auditor.index = technology.name
auditor.i_am_singular = technology.name
auditor.items = auditor.read_previous_items()
auditor.audit_objects()
try:
auditor.save_issues()
except AttributeError as e:
self.fail("Auditor.save_issues() raised AttributeError unexpectedly: {}".format(e.message))
def test_valid_facebook_id_should_delete_person(self):
person = mixer.blend(Person, facebook_id='123123')
db.session.add(person)
db.session.flush()
self.assertEqual(1, Person.query.count())
response = self.client.delete('/person/123123')
self.assertEqual(204, response.status_code)
self.assertEqual(0, Person.query.count())
def generate_test_data():
with app.app_context():
user = mixer.blend(User,
fb_first_name=mixer.RANDOM,
fb_last_name=mixer.RANDOM,
fb_id=mixer.RANDOM,
email=mixer.RANDOM,
about_me=mixer.RANDOM)
db.session.add(user)
issue = mixer.blend(Issue,
reporter='1',
description=mixer.RANDOM,
coordinates='POINT(49 22)')
db.session.add(issue)
comment = mixer.blend(Comment,
author_id='1',
issue_id='1',
message=mixer.RANDOM)
db.session.add(comment)
db.session.commit()
def setup():
userRole = Role.first(name='user') #Get the 'user' role or create it
if not userRole:
userRole = Role.create(name='user', description='provides basic system access', bitmask=2)
adminRole = Role.first(name='admin') #Get the 'admin' role or create it
if not adminRole:
adminRole = Role.create(name='admin', description='provides admin level system access', bitmask=4)
if not User.first(email="*****@*****.**"):
mixer.blend('app.models.users.User', email="*****@*****.**", password=encrypt_password('hello'),
confirmed_at=datetime.now(), roles=[userRole])
if not User.first(email="*****@*****.**"):
mixer.blend('app.models.users.User', email="*****@*****.**", password=encrypt_password('world'),
roles=[userRole])
if not User.first(email="*****@*****.**"):
mixer.blend('app.models.users.User', email="*****@*****.**", password=encrypt_password('supersecret'),
roles=[adminRole])
def test_get_name_full(self):
customer = mixer.blend(Customer, first_name="Test", last_name="Customer")
self.assertEqual(customer.get_name(), "Test Customer")
def test_get_name_anonymous(self):
customer = mixer.blend(Customer)
self.assertEqual(customer.get_name(), "Anonymous customer")
def test_is_initialized_with_zero_balance(self):
customer = mixer.blend(Customer)
self.assertEqual(customer.balance, 0)
def test_is_direct_access_to_balance_forbidden(self):
customer = mixer.blend(Customer)
with self.assertRaises(RuntimeError):
customer.balance = 100
def test_create_customer(self):
mixer.blend(Customer)
def test_get_name_last_only(self):
customer = mixer.blend(Customer, first_name="Customer")
self.assertEqual(customer.get_name(), "Customer")
def test_default_mixer(self):
from mixer.backend.flask import mixer
test = mixer.blend(User)
self.assertTrue(test.username)
