def mockup(cls):
god = God()
god.email = '*****@*****.**'
god.password = '******'
god.is_active = True
DBSession.add(god)
DBSession.commit()
def test_activation_mixin(self):
activated_student = Student()
activated_student.name = 'activated-student'
activated_student.activated_at = datetime.now()
DBSession.add(activated_student)
deactivated_student = Student()
deactivated_student.name = 'deactivated-student'
deactivated_student.activated_at = None
DBSession.add(deactivated_student)
DBSession.commit()
# Test ordering:
student_list = Student.query.order_by(desc(Student.is_active)).all()
self.assertIsNotNone(student_list[0].activated_at)
self.assertIsNone(student_list[-1].activated_at)
student_list = Student.query.order_by(asc(Student.is_active)).all()
self.assertIsNotNone(student_list[-1].activated_at)
self.assertIsNone(student_list[0].activated_at)
# Test filtering:
student_list = Student.query.filter(Student.is_active).all()
for student in student_list:
self.assertIsNotNone(student.activated_at)
student_list = Student.query.filter(not_(Student.is_active)).all()
for student in student_list:
self.assertIsNone(student.activated_at)
def patch(self: Controller):
"""
Set context.method
Set context.form
:return:
"""
# Preserve patches
patches = context.form
results = []
context.jsonpatch = True
try:
for patch in patches:
context.form = patch.get('value', {})
context.method = patch['op']
remaining_paths = patch['path'].split('/')
if remaining_paths and not remaining_paths[0]:
return_data = self()
else:
return_data = self(*remaining_paths)
results.append(return_data)
DBSession.flush()
DBSession.commit()
return '[%s]' % ',\n'.join(results)
except:
if DBSession.is_active:
DBSession.rollback()
raise
finally:
del context.jsonpatch
def test_approve_required_mixin(self):
# noinspection PyArgumentList
object1 = ApproveRequiredObject(
title='object 1',
)
DBSession.add(object1)
DBSession.commit()
self.assertFalse(object1.is_approved)
self.assertEqual(DBSession.query(ApproveRequiredObject).filter(ApproveRequiredObject.is_approved).count(), 0)
object1.is_approved = True
self.assertTrue(object1.is_approved)
DBSession.commit()
object1 = DBSession.query(ApproveRequiredObject).one()
self.assertTrue(object1.is_approved)
json = object1.to_dict()
self.assertIn('isApproved', json)
self.assertEqual(DBSession.query(ApproveRequiredObject).filter(ApproveRequiredObject.is_approved).count(), 1)
self.assertEqual(ApproveRequiredObject.filter_approved().count(), 1)
self.assertFalse(ApproveRequiredObject.import_value(ApproveRequiredObject.is_approved, 'false'))
self.assertFalse(ApproveRequiredObject.import_value(ApproveRequiredObject.is_approved, 'FALSE'))
self.assertFalse(ApproveRequiredObject.import_value(ApproveRequiredObject.is_approved, 'False'))
self.assertTrue(ApproveRequiredObject.import_value(ApproveRequiredObject.is_approved, 'true'))
self.assertTrue(ApproveRequiredObject.import_value(ApproveRequiredObject.is_approved, 'TRUE'))
self.assertTrue(ApproveRequiredObject.import_value(ApproveRequiredObject.is_approved, 'True'))
self.assertEqual(ApproveRequiredObject.import_value(ApproveRequiredObject.title, 'title'), 'title')
def mockup():
with StoreManager(DBSession):
images = PlaceImageList([
PlaceImage.create_from(f'{IMAGE_PATH}/1.jpeg'),
PlaceImage.create_from(f'{IMAGE_PATH}/2.jpeg'),
])
categories = [
Category(name='جنگل', ),
Category(name='رودخونه', ),
Category(name='کوه', ),
Category(name='مذهبی', ),
]
for i in range(1000):
place = Place(
name=f'foo {i}',
description=description,
address=address,
latitude=random() * 20 + 30,
longitude=random() * 20 + 30,
images=images,
category=choice(categories),
)
DBSession.add(place)
DBSession.commit()
def insert():
god = Member(id=1,
email='*****@*****.**',
title='GOD',
access_token='access token',
reference_id=1)
user1 = Member(id=2,
email='*****@*****.**',
title='user_1',
access_token='access token1',
reference_id=2)
user2 = Member(id=3,
email='*****@*****.**',
title='user_2',
access_token='access token2',
reference_id=3)
user3 = Member(id=4,
email='*****@*****.**',
title='user_3',
access_token='access token3',
reference_id=4)
room = Room(title='example', members=[god, user1, user2, user3])
direct1 = Direct(members=[god, user1])
direct2 = Direct(members=[god, user2])
DBSession.add(room)
DBSession.add(direct1)
DBSession.add(direct2)
DBSession.commit()
def verify_token(self, encoded_token):
principal = CASPrincipal.load(encoded_token)
member = DBSession.query(Member) \
.filter(Member.reference_id == principal.reference_id) \
.one_or_none()
if not member and not 'HTTP_X_OAUTH2_ACCESS_TOKEN' in context.environ:
raise HTTPBadRequest()
access_token = context.environ['HTTP_X_OAUTH2_ACCESS_TOKEN'] \
if 'HTTP_X_OAUTH2_ACCESS_TOKEN' in context.environ \
else member.access_token
cas_member = CASClient().get_member(access_token)
if cas_member['email'] != principal.email:
raise HTTPBadRequest()
if member:
if member.title != cas_member['title']:
member.title = cas_member['title']
if member.first_name != cas_member['firstName']:
member.first_name = cas_member['firstName']
if member.avatar != cas_member['avatar']:
member.avatar = cas_member['avatar']
if member.last_name != cas_member['lastName']:
member.last_name = cas_member['lastName']
DBSession.commit()
return principal
def test_modified_mixin(self):
# noinspection PyArgumentList
instance = ModificationCheckingModel(
title='test title',
)
DBSession.add(instance)
DBSession.commit()
self.assertIsNone(instance.modified_at)
self.assertIsNotNone(instance.created_at)
self.assertEqual(instance.last_modification_time, instance.created_at)
instance = DBSession.query(ModificationCheckingModel).one()
self.assertIsNone(instance.modified_at)
self.assertIsNotNone(instance.created_at)
self.assertEqual(instance.last_modification_time, instance.created_at)
instance.title = 'Edited title'
DBSession.commit()
self.assertIsNotNone(instance.modified_at)
self.assertIsNotNone(instance.created_at)
self.assertEqual(instance.last_modification_time, instance.modified_at)
instance = DBSession.query(ModificationCheckingModel).one()
self.assertIsNotNone(instance.modified_at)
self.assertIsNotNone(instance.created_at)
self.assertEqual(instance.last_modification_time, instance.modified_at)
def insert_mockup(self, args=None): # pragma: no cover
from restfulpy.orm import DBSession
from .models import User
oscar = User(id='pylover',
email='*****@*****.**',
password='******')
DBSession.add(oscar)
DBSession.commit()
def __call__(self, args):
user = User(
id=args.name,
email=args.email,
password=getpass()
)
DBSession.add(user)
DBSession.commit()
def insert_mockup(self):
for i in range(1, 11):
# noinspection PyArgumentList
DBSession.add(
Resource(id=i,
title='resource%s' % i,
password='******' % i))
DBSession.commit()
def insert_basedata(self): # pragma: no cover
cell1 = Cell(x=0, y=0, is_alive=True)
DBSession.add(cell1)
cell2 = Cell(x=1, y=0, is_alive=True)
DBSession.add(cell2)
cell3 = Cell(x=0, y=1, is_alive=True)
DBSession.add(cell3)
cell4 = Cell(x=1, y=1)
DBSession.add(cell4)
DBSession.commit()
def test_auto_activation(self):
# noinspection PyArgumentList
object1 = AutoActiveObject(title='object 1', )
DBSession.add(object1)
DBSession.commit()
self.assertTrue(object1.is_active)
self.assertEqual(
1,
DBSession.query(AutoActiveObject).filter(
AutoActiveObject.is_active).count())
def test_orderable_mixin(self):
for i in range(3):
# noinspection PyArgumentList
instance = OrderableCheckingModel(title='test title %s' % i,
order=i)
DBSession.add(instance)
DBSession.commit()
instances = OrderableCheckingModel.apply_default_sort().all()
self.assertEqual(instances[0].order, 0)
self.assertEqual(instances[2].order, 2)
def insert(): # pragma: no cover
my_card1 = MyCard(
title='my card 1',
avatar=
'https://fiverr-res.cloudinary.com/images/t_main1,q_auto,f_auto/gigs/59968744/original/6d9924b6f58a09e5b9c64feb39b557e96f4a765b/give-you-a-one-dollar-virtual-bank-card.jpg',
)
DBSession.add(my_card1)
my_card2 = MyCard(
title='my card 2',
avatar=
'https://www.themelooks.org/club/crypcard/wp-content/uploads/2018/11/1529504445888.jpg',
)
DBSession.add(my_card2)
my_card3 = MyCard(
title='my card 3',
avatar='https://theexchange.africa/wp-content/uploads/2018/09/Visa.jpg',
)
DBSession.add(my_card3)
my_card4 = MyCard(
title='my card 4',
avatar=
'https://techcrunch.com/wp-content/uploads/2017/04/biometric_040517.jpg?w=730&crop=1',
)
DBSession.add(my_card4)
my_card5 = MyCard(
title='my card 5',
avatar=
'https://www.themelooks.org/club/crypcard/wp-content/uploads/2018/11/1529504445888.jpg',
)
DBSession.add(my_card5)
other_card_1 = OtherCard(title='other card 1', )
DBSession.add(other_card_1)
other_card_2 = OtherCard(
title='other card 2',
avatar=
'https://ecobank.com/img/eco/Ecobank_Card_PAC-Prepaid_SalaryXPress_EN_MGD_HR.png',
)
DBSession.add(other_card_2)
other_card_3 = OtherCard(
title='other card 3',
avatar=
'https://techcrunch.com/wp-content/uploads/2017/04/biometric_040517.jpg?w=730&crop=1',
)
DBSession.add(other_card_3)
DBSession.commit()
def insert_mockup(self):
url = Url(url='http://www.varzesh3.com')
member = Member(
given_name='mohammad',
family_name='sheikhian',
email='*****@*****.**',
google_access_token='fgbsdibfosdnfosd',
google_refresh_token='fgbdyugbdsiubgdufig'
)
DBSession.add(url)
DBSession.add(member)
DBSession.commit()
def __call__(self, args):
user = DBSession.query(User).filter(User.id == args.name).one_or_none()
if user is None:
print(f'Invalid username: {args.name}', file=sys.stderr)
return 1
if input(
f'Are you sure to delete the user: {user.id}? [N/y] '
).casefold() != 'y'.casefold():
print(f'User: {args.name} is not deleted', file=sys.stderr)
return 1
DBSession.delete(user)
DBSession.commit()
def __call__(self, args):
user = DBSession.query(User).filter(User.id == args.name).one_or_none()
if user is None:
print(f'Invalid username: {args.name}', file=sys.stderr)
return 1
password=getpass('New Password:'******'Again:')
if password != confirm:
print(f'Passwords are mismatch.', file=sys.stderr)
return 1
user.password=password
DBSession.commit()
def launch(self):
member = DBSession.query(Member)\
.filter(Member.id == self.args.member_id)\
.one_or_none()
if member is None:
print(f'Invalid member id: {self.args.member_id}', file=sys.stderr)
return 1
member.access_token = self.args.access_token
DBSession.commit()
token = member.create_jwt_principal()
print(token.dump().decode())
def post(self):
url = context.form.get('url')
if not url.startswith('http'):
url = f'http://{url}'
url_exist = DBSession.query(Url).filter_by(url=url).one_or_none()
if url_exist is None:
url_exist = Url(url=url)
DBSession.add(url_exist)
DBSession.commit()
hash_id = hashids.encode(url_exist.id)
return dict(hash_id=hash_id)
def patch(self: Controller):
try:
results = super().patch()
DBSession.commit()
results = [r.to_dict() if hasattr(r, 'to_dict') else r \
for r in results]
return results
except:
if DBSession.is_active:
DBSession.rollback()
raise
finally:
del context.jsonpatch
def insert(): # pragma: no cover
admin = Member(
title='GOD',
first_name='First name',
last_name='Last name',
email='*****@*****.**',
password='******',
)
DBSession.add(admin)
DBSession.commit()
print('Admin has been created.')
print(f' Title: {admin.title}\n'
f' First Name: {admin.first_name}\n'
f' Last Name: {admin.last_name}\n'
f' Email: {admin.email}\n'
f' Password: 123456\n')
def get(self):
if(context.query_string.get('code') is None) or \
(client_secret_data['client_id'] is None) or \
(client_secret_data['client_secret'] is None):
raise HttpBadRequest
body_token = dict()
body_token['grant_type'] = 'authorization_code'
body_token['code'] = context.query_string.get('code')
body_token['client_id'] = client_secret_data['client_id']
body_token['redirect_uri'] = settings.redirect_uri_auth
body_token['client_secret'] = client_secret_data['client_secret']
response_token = requests.post(settings.auth_google_uri_token,
body_token)
if response_token.status_code != 200:
raise HttpForbidden()
response_get_profile = requests.get(
settings.oauth_url_google_api,
headers={
'Authorization':
'OAuth ' +
json_library.loads(response_token.text)['access_token']
})
if response_get_profile.status_code != 200:
raise HttpNotFound()
profile = json_library.loads(response_get_profile.text)
if 'refresh_token' in response_token.text:
member = Member(given_name=profile['given_name'],
family_name=profile['family_name'],
email=profile['email'],
google_access_token=json_library.loads(
response_token.text)['access_token'],
google_refresh_token=json_library.loads(
response_token.text)['refresh_token'])
DBSession.add(member)
DBSession.commit()
return dict(authorization=JwtPrincipal(profile).dump().decode("utf-8"))
def post(self):
if context.form.get('url') is None:
raise HttpBadRequest()
url = context.form.get('url')
if not url.startswith('http'):
url = f'http://{url}'
url_exist = DBSession.query(Url).filter_by(url=url).one_or_none()
if url_exist is None:
url_exist = Url(url=url)
DBSession.add(url_exist)
DBSession.commit()
hash_id = hashids.encode(url_exist.id)
return dict(shortener_url=f'http://localhost:8080/urls/{hash_id}')
def __call__(self, args=None):
if args.version:
print(__version__)
return
self.application = MockupApplication()
self.application.configure(filename=args.config_file)
#if exists(db):
# os.remove(db)
# makedirs(settings.data_directory, exist_ok=True)
self.application.initialize_orm()
setup_schema()
DBSession.execute('TRUNCATE TABLE resource')
DBSession.commit()
print(f'DB {DBSession.bind}')
self.application.insert_mockup()
host, port = args.bind.split(':') if ':' in args.bind else (
'localhost', args.bind)
httpd = make_server(host, int(port), self.application)
url = 'http://%s:%d' % httpd.server_address
print(
f'The server is up!, Get {url} to more info about how to use it!')
server_thread = threading.Thread(target=httpd.serve_forever,
daemon=True)
try:
server_thread.start()
if not args.command:
server_thread.join()
exitstatus = 0
else:
test_runner_command = ' '.join(args.command).replace(
'{url}', url)
time.sleep(1)
result = run(test_runner_command, shell=True)
exitstatus = result.returncode
return exitstatus
except KeyboardInterrupt:
print('CTRL+X is pressed.')
return 1
finally:
httpd.shutdown()
sys.exit(exitstatus)
def test_pagination_mixin(self):
for i in range(1, 6):
# noinspection PyArgumentList
obj = PagingObject(
title='object %s' % i,
)
DBSession.add(obj)
DBSession.commit()
with Context({'QUERY_STRING': 'take=2&skip=1'}, self.application) as context:
self.assertEqual(PagingObject.paginate_by_request().count(), 2)
self.assertEqual(context.response_headers['X-Pagination-Take'], '2')
self.assertEqual(context.response_headers['X-Pagination-Skip'], '1')
self.assertEqual(context.response_headers['X-Pagination-Count'], '5')
with Context({'QUERY_STRING': 'take=two&skip=one'}, self.application):
self.assertEqual(PagingObject.paginate_by_request().count(), 4)
with Context({'QUERY_STRING': 'take=5'}, self.application):
self.assertRaises(HttpBadRequest, PagingObject.paginate_by_request)
def patch(self: Controller):
"""
Set context.method
Set context.form
:return:
"""
# Preserve patches
patches = context.form
results = []
context.jsonpatch = True
try:
for patch in patches:
context.form = patch.get('value', {})
path, context.query = split_path(patch['path'])
context.method = patch['op'].lower()
context.request_content_length = \
len(context.form) if context.form else 0
remaining_paths = path.split('/')
if remaining_paths and not remaining_paths[0]:
return_data = self()
else:
return_data = self(*remaining_paths)
if isinstance(return_data, types.GeneratorType):
results.append('"%s"' % ''.join(list(return_data)))
else:
results.append(return_data)
DBSession.flush()
context.query = {}
DBSession.commit()
return '[%s]' % ',\n'.join(results)
except:
if DBSession.is_active:
DBSession.rollback()
raise
finally:
del context.jsonpatch
def test_soft_delete_mixin(self):
# noinspection PyArgumentList
instance = SoftDeleteCheckingModel(title='test title')
DBSession.add(instance)
DBSession.commit()
instance.assert_is_not_deleted()
self.assertRaises(ValueError, instance.assert_is_deleted)
instance = SoftDeleteCheckingModel.query.one()
instance.soft_delete()
DBSession.commit()
instance.assert_is_deleted()
self.assertRaises(ValueError, instance.assert_is_not_deleted)
self.assertEqual(SoftDeleteCheckingModel.filter_deleted().count(), 1)
self.assertEqual(SoftDeleteCheckingModel.exclude_deleted().count(), 0)
instance.soft_undelete()
DBSession.commit()
instance.assert_is_not_deleted()
self.assertRaises(ValueError, instance.assert_is_deleted)
self.assertEqual(SoftDeleteCheckingModel.filter_deleted().count(), 0)
self.assertEqual(SoftDeleteCheckingModel.exclude_deleted().count(), 1)
DBSession.delete(instance)
self.assertRaises(HttpConflict, DBSession.commit)
def test_activation_mixin(self):
# noinspection PyArgumentList
object1 = ActiveObject(title='object 1', )
DBSession.add(object1)
DBSession.commit()
self.assertFalse(object1.is_active)
self.assertEqual(
DBSession.query(ActiveObject).filter(
ActiveObject.is_active).count(), 0)
object1.is_active = True
self.assertTrue(object1.is_active)
DBSession.commit()
object1 = DBSession.query(ActiveObject).one()
self.assertTrue(object1.is_active)
json = object1.to_dict()
self.assertIn('isActive', json)
self.assertEqual(
DBSession.query(ActiveObject).filter(
ActiveObject.is_active).count(), 1)
self.assertEqual(ActiveObject.filter_activated().count(), 1)
self.assertFalse(
ActiveObject.import_value(ActiveObject.is_active, 'false'))
self.assertFalse(
ActiveObject.import_value(ActiveObject.is_active, 'FALSE'))
self.assertFalse(
ActiveObject.import_value(ActiveObject.is_active, 'False'))
self.assertTrue(
ActiveObject.import_value(ActiveObject.is_active, 'true'))
self.assertTrue(
ActiveObject.import_value(ActiveObject.is_active, 'TRUE'))
self.assertTrue(
ActiveObject.import_value(ActiveObject.is_active, 'True'))
self.assertEqual(
ActiveObject.import_value(ActiveObject.title, 'title'), 'title')
def insert():
god = Member(
user_name='GOD',
email='*****@*****.**',
first_name='god',
last_name='godian',
password='******',
)
DBSession.add(god)
member1 = Member(
user_name='member1',
email='*****@*****.**',
first_name='member1',
last_name='family member1',
password='******',
)
DBSession.add(member1)
member2 = Member(
user_name='member2',
email='*****@*****.**',
first_name='member2',
last_name='family member1',
password='******',
)
DBSession.add(member2)
DBSession.commit()
bot1 = Bot(
name='bot',
title='bot-title',
owner_id=member1.id,
)
DBSession.add(bot1)
DBSession.commit()
print('Following member has been added:')
print(god.user_name)
