def test_paginated_sharedfiles_and_count(self):
"""
Tests both the pagination of a shake's shared files and the count
"""
sharedfiles = []
sourcefile = Sourcefile(width=20,
height=20,
file_key="asdf",
thumb_key="asdf_t")
sourcefile.save()
for i in range(31):
sf = Sharedfile(source_id=sourcefile.id,
name="my shared file",
user_id=self.user.id,
content_type="image/png",
share_key="1",
description="some\ndescription\nhere",
source_url="https://www.mltshp.com/?hi")
sf.save()
sf.add_to_shake(self.shake)
sharedfiles.append(sf)
self.assertEqual(len(self.shake.sharedfiles()), 10) #default
self.assertEqual(len(self.shake.sharedfiles(page=1)), 10)
self.assertEqual(len(self.shake.sharedfiles(page=2)), 10)
self.assertEqual(len(self.shake.sharedfiles(page=3)), 10)
self.assertEqual(len(self.shake.sharedfiles(page=4)), 1)
self.assertEqual(len(self.shake.sharedfiles(page=1, per_page=31)), 31)
def test_pagination_returns_correct_counts(self):
"""
This tests creating 111 shared files for a user and then tests that pagination
on their user page returns the correct pages
"""
user = User.get('name="admin"')
user_shake = user.shake()
source_file = Sourcefile(width=10,
height=10,
file_key='mumbles',
thumb_key='bumbles')
source_file.save()
missing_ids = []
for i in range(111):
sf = Sharedfile(source_id=source_file.id,
user_id=user.id,
name="shgaredfile.png",
title='shared file',
share_key='asdf',
content_type='image/png',
deleted=0)
sf.save()
sf.add_to_shake(user_shake)
for i in range(12):
response = self.fetch('/user/admin/%s' % (i + 1))
self.assertEqual(response.code, 200)
def test_shared_files_count_ignores_deleted(self):
"""
This test checks that an account with deleted files will not return them in the
User.sharedfiles() or User.sharedfiles_count() methods
"""
# User should have one sharedfile have one from the setUp
self.assertEqual(self.user.sharedfiles_count(), 1)
missing_ids = []
for i in range(50):
sf = Sharedfile(source_id=self.sourcefile.id,
user_id=self.user.id,
name="shgaredfile.png",
title='shared file',
share_key='asdf',
content_type='image/png')
sf.save()
sf.add_to_shake(self.user_shake)
if i and (50 % i) == 0: #2 5 10 and 25
sf.delete()
missing_ids.append(sf.id)
self.assertEqual(self.user.sharedfiles_count(), 46)
users_shared_files = self.user.sharedfiles()
for f in users_shared_files:
self.assertTrue(f.id not in missing_ids)
def test_query_friend_shake_before_after(self):
"""
Admin (user_a), who user2 (user_b) follows, uploads 10 files, which appear in
Admin's stream.
/friends/before/{share_key} should return all files that came before passed in share_key
while /friends/after/{share_key} should return those that came after.
We assume there is already one file uploaded by Admin (share_key -> 1)
"""
files = []
for x in range(10):
source_file = Sourcefile(width=10, height=10, file_key='mumbles', thumb_key='bumbles')
source_file.save()
sf = Sharedfile(source_id = source_file.id, user_id = self.user_a.id, name="shgaredfile.png",
title='shared file', content_type='image/png', deleted=0)
sf.save()
sf.share_key = base36encode(sf.id)
sf.save()
sf.add_to_shake(self.user_a.shake())
files.append(sf)
request = signed_request(self.access_token, self.get_url('/api/friends/before/%s' % files[3].share_key))
self.http_client.fetch(request, self.stop)
response = self.wait()
j_response = json_decode(response.body)
self.assertEqual(4, len(j_response['friend_shake']))
request = signed_request(self.access_token, self.get_url('/api/friends/after/%s' % files[3].share_key))
self.http_client.fetch(request, self.stop)
response = self.wait()
j_response = json_decode(response.body)
self.assertEqual(6, len(j_response['friend_shake']))
def test_delete_user(self):
user_to_del = User(name='user_delete',
email='*****@*****.**',
email_confirmed=1,
is_paid=1)
user_to_del.set_password('asdfasdf')
user_to_del.save()
sourcefile = Sourcefile(width=20,
height=20,
file_key="asdf",
thumb_key="asdf_t")
sourcefile.save()
sharedfile = Sharedfile(source_id=sourcefile.id,
name="my shared file",
user_id=user_to_del.id,
content_type="image/png",
share_key="ok")
sharedfile.save()
user_shake = user_to_del.shake()
sharedfile.add_to_shake(user_shake)
self.post_url('/admin/delete-user',
arguments={
'user_id': user_to_del.id,
'user_name': user_to_del.name
})
deleted_user = User.get('id = %s and name = %s', user_to_del.id,
user_to_del.name)
self.assertEqual(deleted_user.deleted, 1)
sf = Sharedfile.get('id=%s', sharedfile.id)
self.assertEqual(sf.deleted, 1)
def on_thumbnail_response(self, response):
if response.code != 200:
self.render(
"tools/save-video-error.html",
message=
"We could not load the thumbnail for this file and therefore could not save this video. Please contact support."
)
return
# save the response
url = self.get_argument('url')
current_user = self.get_current_user_object()
sha1_key = Sourcefile.get_sha1_file_key(file_path=None, file_data=url)
thumbnail_path = "%s/%s" % (options.uploaded_files, sha1_key)
fh = open(thumbnail_path, 'wb')
fh.write(response.body)
fh.close()
source_file = Sourcefile.create_from_json_oembed(
link=url,
oembed_doc=self.oembed_doc,
thumbnail_file_path=thumbnail_path)
#cleanup
if not options.debug:
try:
os.remove(thumbnail_path)
except:
pass
title = ''
if self.oembed_doc.has_key('title'):
title = self.oembed_doc['title']
shared_file = Sharedfile(user_id=current_user.id,
name=url,
content_type='text/html',
source_id=source_file.id,
title=title,
source_url=url)
shared_file.save()
share_key = base36encode(shared_file.id)
shared_file.share_key = share_key
shared_file.save()
user_shake = Shake.get('user_id = %s and type=%s', current_user.id,
'user')
shared_file.add_to_shake(self.destination_shake)
if self.oembed_doc.has_key('description'):
shared_file.description = self.oembed_doc['description']
self.write({'path': "/p/%s" % (share_key)})
self.finish()
def _post_to_shake(self, user, to_shake=None):
"""
Utility method for creating a post to a shake. If shake is
not specified, the newly created sharedfile will be added to
the user's shake.
"""
source_file = Sourcefile(width=10, height=10, file_key='mumbles', thumb_key='bumbles')
source_file.save()
sf = Sharedfile(source_id=source_file.id, user_id=user.id, name="sharedfile.png",
title='shared file', content_type='image/png', deleted=0)
sf.save()
sf.share_key = base36encode(sf.id)
sf.save()
if to_shake:
sf.add_to_shake(to_shake)
else:
sf.add_to_shake(user.shake())
return sf
def test_subscription_timeline_shows_appropriate_images(self):
"""
We have a user subscribe to the shakes of 2 other users. The users
that are being subscribed to have one sharedfile each, both pointing
to same source file.
When a user subscribes, his timeline will be populated with last 10
posts from user being subscribed to. In this case, timeline will
suppress dupes.
"""
user1 = User(name='user', email='*****@*****.**', is_paid=1)
user1.save()
source_file = Sourcefile(width=10,
height=10,
file_key='mumbles',
thumb_key='bumbles')
source_file.save()
users = ['user2', 'user3', 'user4']
for name in users:
user = User(name=name, email='*****@*****.**' % (name), is_paid=1)
user.save()
sf = Sharedfile(source_id=source_file.id, user_id = user.id, name='%s file.jpg' % (name), \
title='%s file' % (name), share_key='%s' % (name), content_type='image/jpg', deleted=0)
sf.save()
sf.add_to_shake(user.shake())
# have user follow two users' shakes
user2 = User.get('name=%s', 'user2')
user3 = User.get('name=%s', 'user3')
user1.subscribe(user2.shake())
user1.subscribe(user3.shake())
shared_files = user1.sharedfiles_from_subscriptions()
self.assertEqual(1, len(shared_files))
self.assertEqual(shared_files[0].source_id, source_file.id)
shared_files[0].deleted = 1
shared_files[0].save()
# they should no longer see the shared file since it
# was deleted.
shared_files = user1.sharedfiles_from_subscriptions()
self.assertEqual(0, len(shared_files))
def test_user_paid_account_rss_works(self):
sourcefile = Sourcefile(width=20,
height=20,
file_key="asdf",
thumb_key="asdf_t")
sourcefile.save()
sharedfile = Sharedfile(source_id=sourcefile.id, name="the name",user_id=self.user.id, \
content_type="image/png", description="description", source_url="https://www.mltshp.com/?hi")
sharedfile.save()
sharedfile.share_key = lib.utilities.base36encode(sharedfile.id)
sharedfile.save()
sharedfile.add_to_shake(self.user.shake())
response = self.fetch_url('/user/admin/rss')
self.assertEqual(response.headers['Content-Type'], 'application/xml')
parsed_xml = lib.utilities.parse_xml(response.body)
self.assertEqual(parsed_xml['rss']['channel']['item']['link'],
'https://mltshp.com/p/1')
class UserModelTests(BaseTestCase):
def setUp(self):
"""
Create a user, a source file and a shared file to user in tests.
"""
super(UserModelTests, self).setUp()
self.user = User(name='example',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
self.user.save()
self.sourcefile = Sourcefile(width=20,height=20,file_key="asdf", \
thumb_key="asdf_t")
self.sourcefile.save()
self.sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file", \
user_id=self.user.id, content_type="image/png", share_key="ok")
self.sharedfile.save()
self.user_shake = self.user.shake()
self.sharedfile.add_to_shake(self.user_shake)
def test_user_uniqueness(self):
"""
Can't create a user with same user name or email. Save should return False, no new
users should be added.
"""
user = User(name='unique_user',
email='*****@*****.**',
verify_email_token='created',
password='******',
email_confirmed=1,
is_paid=1)
user.save()
users_in_db = User.all("where name = '%s'" % ('unique_user'))
self.assertEqual(1, len(users_in_db))
# same name, different email shouldn't save.
user = User(name='unique_user',
email='*****@*****.**',
verify_email_token='created',
password='******',
email_confirmed=1,
is_paid=1)
self.assertFalse(user.save())
users_in_db = User.all("where name = '%s'" % ('unique_user'))
self.assertEqual(1, len(users_in_db))
# same email, different name
user = User(name='different_name',
email='*****@*****.**',
verify_email_token='created',
password='******',
email_confirmed=1,
is_paid=1)
self.assertFalse(user.save())
users_in_db = User.all("where email = '%s'" %
('*****@*****.**'))
self.assertEqual(1, len(users_in_db))
# both different, should save.
user = User(name='different_name',
email='*****@*****.**',
verify_email_token='created',
password='******',
email_confirmed=1,
is_paid=1)
self.assertTrue(user.save())
users_in_db = User.all("where email = %s and name = %s",
'*****@*****.**', 'different_name')
self.assertEqual(1, len(users_in_db))
def test_user_password_storage(self):
"""
Tests that a set of passwords correctly get set as the hashed_password
"""
options.auth_secret = 'ne4om9og3maw8orp2ot9quos5ed8aj3lam6up3ja'
passwords = [
('asdf1234', 'f9d7082750f934412bb8e86c83432a027f2e92fb'),
('k23(jsdjfsdlk'
'wlkj\nfpbd)', '0ccc0cbce78403de22b5065a81238d9ab0a82f1f'),
('$55233234234', '8b57e7ee9feab3d7083debc1f2c97810329ed3bb')
]
for password in passwords:
u = User(name=self.generate_string_of_len(random.randint(1, 30)),
email=self.generate_string_of_len(6) + '@example.com',
email_confirmed=1,
is_paid=1)
u.set_and_confirm_password(password[0], password[0])
u.save()
self.assertEqual(u.hashed_password, password[1])
#def test_existing_user_and_password_are_upgraded_to_bcrypt(self):
# """
# Tests that a set of users with existing hashed password get upgraded on calling authenticate
# """
# options.auth_secret = 'ne4om9og3maw8orp2ot9quos5ed8aj3lam6up3ja'
# passwords = [
# ('asdf1234', 'f9d7082750f934412bb8e86c83432a027f2e92fb'),
# ('k23(jsdjfsdlk''wlkj\nfpbd)', '0ccc0cbce78403de22b5065a81238d9ab0a82f1f'),
# ('$55233234234', '8b57e7ee9feab3d7083debc1f2c97810329ed3bb')
# ]
# for password in passwords:
# this_user = self.generate_string_of_len(random.randint(1,30))
# u = User(name=this_user, email=self.generate_string_of_len(6) + '@example.com', email_confirmed=1, is_paid=1)
# u.set_and_confirm_password(password[0],password[0])
# u.save()
# u.authenticate(this_user, password[0])
# u = User.get(u.id)
# self.assertNotEqual(u.hashed_password, password[1])
# #YOU WERE HERE TESTING THAT CALLING AUTH UPGRADES TO BCRYPT
def test_user_name_is_unique(self):
name = self.generate_string_of_len(random.randint(1, 30))
password = self.generate_string_of_len(10)
first_user = User(name=name,
email=self.generate_string_of_len(6) +
'@example.com',
email_confirmed=1,
is_paid=1)
first_user.set_and_confirm_password(password, password)
first_user.save()
second_user = User(name=name,
email=self.generate_string_of_len(6) +
'@example.com',
email_confirmed=1,
is_paid=1)
second_user.set_and_confirm_password(password, password)
self.assertFalse(second_user.save())
def test_email_verifier(self):
invalid_emails = [
'asdfasd@', 'asdfi [email protected]', 'ijoafd', 'sdfdsfsijof@dslkfj'
]
valid_emails = [
'*****@*****.**', '*****@*****.**', '*****@*****.**',
'*****@*****.**', '*****@*****.**'
]
for i_email in invalid_emails:
invalid_user = User(name=self.generate_string_of_len(
random.randint(1, 30)),
email=i_email,
email_confirmed=1,
is_paid=1)
self.assertFalse(invalid_user.save())
for v_email in valid_emails:
valid_user = User(name=self.generate_string_of_len(
random.randint(1, 30)),
email=v_email,
email_confirmed=1,
is_paid=1)
self.assertTrue(valid_user.save())
def test_shared_files_count_ignores_deleted(self):
"""
This test checks that an account with deleted files will not return them in the
User.sharedfiles() or User.sharedfiles_count() methods
"""
# User should have one sharedfile have one from the setUp
self.assertEqual(self.user.sharedfiles_count(), 1)
missing_ids = []
for i in range(50):
sf = Sharedfile(source_id=self.sourcefile.id,
user_id=self.user.id,
name="shgaredfile.png",
title='shared file',
share_key='asdf',
content_type='image/png')
sf.save()
sf.add_to_shake(self.user_shake)
if i and (50 % i) == 0: #2 5 10 and 25
sf.delete()
missing_ids.append(sf.id)
self.assertEqual(self.user.sharedfiles_count(), 46)
users_shared_files = self.user.sharedfiles()
for f in users_shared_files:
self.assertTrue(f.id not in missing_ids)
def test_subscription_timeline_shows_appropriate_images(self):
"""
We have a user subscribe to the shakes of 2 other users. The users
that are being subscribed to have one sharedfile each, both pointing
to same source file.
When a user subscribes, his timeline will be populated with last 10
posts from user being subscribed to. In this case, timeline will
suppress dupes.
"""
user1 = User(name='user', email='*****@*****.**', is_paid=1)
user1.save()
source_file = Sourcefile(width=10,
height=10,
file_key='mumbles',
thumb_key='bumbles')
source_file.save()
users = ['user2', 'user3', 'user4']
for name in users:
user = User(name=name, email='*****@*****.**' % (name), is_paid=1)
user.save()
sf = Sharedfile(source_id=source_file.id, user_id = user.id, name='%s file.jpg' % (name), \
title='%s file' % (name), share_key='%s' % (name), content_type='image/jpg', deleted=0)
sf.save()
sf.add_to_shake(user.shake())
# have user follow two users' shakes
user2 = User.get('name=%s', 'user2')
user3 = User.get('name=%s', 'user3')
user1.subscribe(user2.shake())
user1.subscribe(user3.shake())
shared_files = user1.sharedfiles_from_subscriptions()
self.assertEqual(1, len(shared_files))
self.assertEqual(shared_files[0].source_id, source_file.id)
shared_files[0].deleted = 1
shared_files[0].save()
# they should no longer see the shared file since it
# was deleted.
shared_files = user1.sharedfiles_from_subscriptions()
self.assertEqual(0, len(shared_files))
def test_profile_image_url(self):
"""
If there is no user.profile_image, or set to False, should return the default.
Otherwise, should return an Amazon URL.
"""
self.assertEqual(None, self.user.profile_image)
self.assertEqual('/static/images/default-icon-venti.svg',
self.user.profile_image_url())
self.user.profile_image = False
self.user.save()
self.assertEqual('/static/images/default-icon-venti.svg',
self.user.profile_image_url())
self.user.profile_image = True
self.user.save()
self.assertEqual(
1,
self.user.profile_image_url().count(
'amazonaws.com/account/1/profile.jpg'))
def test_add_favorite(self):
"""
A user should be able to favorite a sharedfile if:
- it belongs to another user
- it's not already favorited
- if it's been favorited, but favorite was "deleted"
A user shouldn't be able to favorite a sharedfile if they own it.
"""
# Create new user with their own sharedfile.
new_user = User(name='newuser',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
new_user.save()
new_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file", \
user_id=new_user.id, content_type="image/png", share_key="ok")
new_sharedfile.save()
# One should be able to favorite another user's sharedfile
self.assertTrue(self.user.add_favorite(new_sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(1, len(favorites))
# Can't favorite an already favorited sharedfile.
self.assertFalse(self.user.add_favorite(new_sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(1, len(favorites))
# A favorite with "deleted" flag set, should have flag unset and
# return True when add_favorite called
favorite = Favorite.get("user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
favorite.deleted = True
favorite.save()
self.assertTrue(self.user.add_favorite(new_sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(1, len(favorites))
# Can't favorite one's own sharedfile.
self.assertTrue(self.sharedfile.user_id, self.user.id)
self.assertFalse(self.user.add_favorite(self.sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, self.sharedfile.id)
self.assertEqual(0, len(favorites))
def test_add_favorite_deleted_sharedfile(self):
"""
User.add_favorite should return False if sharedfile is deleted
and no Favorite entries should be logged.
"""
# Create new user with their own sharedfile.
new_user = User(name='newuser',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
new_user.save()
new_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file", \
user_id=new_user.id, content_type="image/png", share_key="ok")
new_sharedfile.save()
new_sharedfile.delete()
self.assertFalse(self.user.add_favorite(new_sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(0, len(favorites))
def test_remove_favorite(self):
"""
User.remove_favorite should return False if the sharedfile has never been favorited or
has been removed.
Should return true if removing favorite succeeds
"""
# Create new user with their own sharedfile.
new_user = User(name='newuser',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
new_user.save()
new_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file", \
user_id=new_user.id, content_type="image/png", share_key="ok")
new_sharedfile.save()
# remove_favorite should return false when sharedfile not already favorited.
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(0, len(favorites))
self.assertFalse(self.user.remove_favorite(new_sharedfile))
# remove_favorite should return True when unfavoring succeeds, deleted
# flag on Favorite should be set to 0. Should return false on a subsequent
# attempt on remove_favorite
self.user.add_favorite(new_sharedfile)
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(1, len(favorites))
self.assertTrue(self.user.remove_favorite(new_sharedfile))
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
self.assertEqual(0, len(favorites))
# remove_favorite on deleted favorite should return False.
favorites = Favorite.all("where user_id = %s and sharedfile_id = %s and deleted = 1", \
self.user.id, new_sharedfile.id)
self.assertEqual(1, len(favorites))
self.assertFalse(self.user.remove_favorite(new_sharedfile))
def test_has_favorite(self):
"""
User.has_favorite should return True if a user has favorited a file. Should return
False if no entry exists, or if entry is marked as "deleted"
"""
# Create new user with their own sharedfile.
new_user = User(name='newuser',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
new_user.save()
new_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file", \
user_id=new_user.id, content_type="image/png", share_key="ok")
new_sharedfile.save()
self.assertFalse(self.user.has_favorite(new_sharedfile))
self.user.add_favorite(new_sharedfile)
self.assertTrue(self.user.has_favorite(new_sharedfile))
favorite = Favorite.get("user_id = %s and sharedfile_id = %s and deleted = 0", \
self.user.id, new_sharedfile.id)
favorite.deleted = True
favorite.save()
self.assertFalse(self.user.has_favorite(new_sharedfile))
def test_saved_sharedfile(self):
"""
User.saved_sharedfile should return None if no
sharedfile saved, otherwisew will return the sharedfile
if it was saved by user. If more than one shardfile saved
by user, it will still return 1.
"""
# Create new user to be doing the saving, and its own sharedfile.
new_user = User(name='newuser',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
new_user.save()
self.assertEqual(None, new_user.saved_sharedfile(self.sharedfile))
self.sharedfile.save_to_shake(new_user)
# check to make sure we get a Sharedfile object back, not None
self.assertEqual(type(self.sharedfile),
type(new_user.saved_sharedfile(self.sharedfile)))
# save another file to user
self.sharedfile.save_to_shake(new_user)
self.assertEqual(type(self.sharedfile),
type(new_user.saved_sharedfile(self.sharedfile)))
def test_use_invitation(self):
"""
user.send_invitation() should send two invitations out and create them with messages saying they are from
that user.
"""
self.user.add_invitations(5)
self.user.send_invitation('*****@*****.**')
self.user.send_invitation('*****@*****.**')
self.assertEqual(self.user.invitation_count, 3)
invitations_sent = invitation.Invitation.all()
self.assertEqual(len(invitations_sent), 2)
for i in invitations_sent:
self.assertEqual(i.user_id, self.user.id)
self.assertTrue(
i.email_address in ['*****@*****.**', '*****@*****.**'])
def test_flag_nsfw(self):
"""
User.flag_nsfw flag should set the nsfw field to 1 in DB.
"""
self.assertEqual(self.user.nsfw, False)
self.user.flag_nsfw()
fetched_user = User.get('id = %s', self.user.id)
self.assertEqual(self.user.nsfw, True)
def test_unflag_nsfw(self):
"""
User.unflag_nsfw should set the nsfw field to 0 in DB.
"""
self.user.nsfw = True
self.user.save()
fetched_user = User.get('id = %s', self.user.id)
self.assertEqual(self.user.nsfw, True)
self.user.unflag_nsfw()
fetched_user = User.get('id = %s', self.user.id)
self.assertEqual(self.user.nsfw, False)
def test_shakes_method_returns_managed_and_owned(self):
"""
Tests that the shakes method returns the correct shake counts
when called with managed and without.
"""
#a new person with a shake
shake_owner = User(name='user1',
email='*****@*****.**',
email_confirmed=1,
is_paid=1)
shake_owner.set_password('asdfasdf')
shake_owner.save()
group_shake = shake_owner.create_group_shake(title='asdf',
name='asdf',
description='adsf')
personal_shake = self.user.create_group_shake(title='qwer',
name='qwer',
description='qwer')
#here's the cool part
group_shake.add_manager(self.user)
shakes_managed = self.user.shakes(include_managed=True)
self.assertEqual(len(shakes_managed), 3)
shakes_owned = self.user.shakes()
self.assertEqual(len(shakes_owned), 2)
self.assertEqual(shakes_owned[0].type, 'user')
self.assertEqual(shakes_owned[1].type, 'group')
def test_cannot_upload_if_over_file_upload_limit_unpaid(self):
"""
Tests whether a user can upload a file if they are over the limit for this month.
"""
self.user.stripe_plan_id = "mltshp-single"
self.user.save()
file_name = 'red.gif'
file_content_type = 'image/gif'
file_path = os.path.abspath("test/files/%s" % (file_name))
file_sha1 = Sourcefile.get_sha1_file_key(file_path)
sf = Sharedfile.create_from_file(file_path=file_path,
file_name=file_name,
sha1_value=file_sha1,
content_type=file_content_type,
user_id=self.user.id)
sf.size = 410000000
sf.save()
self.assertFalse(self.user.can_upload_this_month())
def test_can_upload_if_over_file_upload_limit_paid(self):
"""
Tests whether a user can upload a file if they are over the limit and have paid
for the double scoop plan.
"""
self.user.stripe_plan_id = "mltshp-double"
self.user.save()
file_name = 'red.gif'
file_content_type = 'image/gif'
file_path = os.path.abspath("test/files/%s" % (file_name))
file_sha1 = Sourcefile.get_sha1_file_key(file_path)
sf = Sharedfile.create_from_file(file_path=file_path,
file_name=file_name,
sha1_value=file_sha1,
content_type=file_content_type,
user_id=self.user.id)
sf.size = 310000000
sf.save()
self.assertTrue(self.user.can_upload_this_month())
def test_total_file_count_for_this_month(self):
"""
tests that the current amount of new files uploaded for the current month is correct
"""
images = ['red.gif', 'blue.gif', 'green.gif', 'love.gif']
for image in images:
file_name = image
file_content_type = 'image/gif'
file_path = os.path.abspath("test/files/%s" % (file_name))
file_sha1 = Sourcefile.get_sha1_file_key(file_path)
sf = Sharedfile.create_from_file(file_path=file_path,
file_name=file_name,
sha1_value=file_sha1,
content_type=file_content_type,
user_id=self.user.id)
month_days = calendar.monthrange(datetime.utcnow().year,
datetime.utcnow().month)
start_time = datetime.utcnow().strftime("%Y-%m-01")
end_time = datetime.utcnow().strftime("%Y-%m-" + str(month_days[1]))
self.assertEqual(
self.user.uploaded_kilobytes(start_time=start_time,
end_time=end_time), 72)
def test_is_admin(self):
"""
Only user's with the name admin should return True when User.is_admin is called.
"""
admin = User(name='admin',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
admin.save()
someone_else = User(name='someoneelse',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
someone_else.save()
self.assertTrue(admin.is_admin())
self.assertFalse(someone_else.is_admin())
def test_find_by_name_fragment(self):
"""
User.find_by_name_fragment should return empty array
if None or '' is passed in. Otherwise, should search and find
usernames.
"""
admin = User(name='admin',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
admin.save()
another_user = User(name='another',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, is_paid=1)
another_user.save()
self.assertEqual([], User.find_by_name_fragment('nothing'))
self.assertEqual([], User.find_by_name_fragment())
self.assertEqual(2, len(User.find_by_name_fragment('a')))
self.assertEqual('admin', User.find_by_name_fragment('ad')[0].name)
# test limit
self.assertEqual(1, len(User.find_by_name_fragment('a', limit=1)))
def test_user_delete(self):
self.user.create_group_shake(title='balrag',
name="blahr",
description="affafa")
another_user = User(name='example2',email='*****@*****.**', \
verify_email_token = 'created', password='******', email_confirmed=1, paid=1)
another_user.save()
new_group_shake = another_user.create_group_shake(title='weiurywiuer',
name="werqwerew",
description="affafa")
self.user.subscribe_to_user(another_user)
new_group_shake.add_manager(self.user)
self.user.delete()
user = User.get('name=%s', 'example')
self.assertEqual(user.email, '*****@*****.**' % (user.id))
self.assertEqual(user.hashed_password, 'deleteduseracct')
self.assertEqual(user.about, '')
self.assertEqual(user.website, '')
self.assertEqual(user.nsfw, 1)
self.assertEqual(user.recommended, 0)
self.assertEqual(user.is_paid, 1)
self.assertEqual(user.deleted, 1)
self.assertEqual(user.verify_email_token, 'deleted')
self.assertEqual(user.reset_password_token, 'deleted')
self.assertEqual(user.profile_image, 0)
self.assertEqual(user.disable_notifications, 1)
self.assertEqual(user.invitation_count, 0)
shared_files = Sharedfile.all()
for shared_file in shared_files:
self.assertEqual(shared_file.deleted, 1)
ssfs = Shakesharedfile.all()
for ssf in ssfs:
self.assertEqual(ssf.deleted, 1)
subscriptions = Subscription.where("user_id = %s", self.user.id)
for sub in subscriptions:
self.assertEqual(sub.deleted, 1)
managing = ShakeManager.where("user_id = %s", self.user.id)
for m in managing:
self.assertEqual(m.deleted, 1)
def test_created_shake_contains_file(self):
"""
This test creates three users. User A creates a shake (asdf) and adds a file to it.
User B follows User A
User C follows User A
User B follows User A's shake (asdf)
Getting shared files for B sees file.
Getting shared files for C does not see file.
Getting shared files for A does not see file.
"""
user_a = User(name='user_a',
email='*****@*****.**',
email_confirmed=1,
is_paid=1,
stripe_plan_id="mltshp-double")
user_a.set_password('asdfasdf')
user_a.save()
user_b = User(name='user_b',
email='*****@*****.**',
email_confirmed=1,
is_paid=1)
user_b.set_password('asdfasdf')
user_b.save()
user_c = User(name='user_c',
email='*****@*****.**',
email_confirmed=1,
is_paid=1)
user_c.set_password('asdfasdf')
user_c.save()
self.sign_in('user_a', 'asdfasdf')
arguments = {
'name': 'asdf',
'description': 'A shake test.',
'title': 'Shake Test',
}
self.post_url('/shake/create', arguments=arguments)
self.sign_in('user_b', 'asdfasdf')
shake = Shake.get('name = %s', 'asdf')
self.post_url('/shake/%s/subscribe?json=1' % shake.id)
#create a shared file and source file
sourcefile = Sourcefile(width=20,
height=20,
file_key="asdf",
thumb_key="asdf_t")
sourcefile.save()
sharedfile = Sharedfile(source_id=sourcefile.id, name="the name",user_id=user_a.id, \
content_type="image/png", description="description", source_url="https://www.mltshp.com/?hi")
sharedfile.save()
sharedfile.share_key = lib.utilities.base36encode(sharedfile.id)
sharedfile.save()
new_shake = Shake.get('name=%s', 'asdf')
sharedfile.add_to_shake(new_shake)
shared_files = Sharedfile.from_subscriptions(user_b.id)
self.assertEqual(len(shared_files), 1)
self.assertEqual(shared_files[0].user_id, user_a.id)
#contains one sub to their created shake
self.assertEqual(len(Sharedfile.from_subscriptions(user_a.id)), 1)
self.assertEqual(len(Sharedfile.from_subscriptions(user_c.id)), 0)
def test_rss_feed_works(self):
"""
Testing that the RSS feed works.
"""
self.user.stripe_plan_id = "mltshp-double"
self.user.save()
arguments = {
'name': 'yo',
'description': 'My little corner of the world',
'title': 'title'
}
response = self.post_url('/shake/create', arguments=arguments)
s = Shake.get('name=%s', 'yo')
#create a shared file and source file
sourcefile = Sourcefile(width=20,
height=20,
file_key="asdf",
thumb_key="asdf_t")
sourcefile.save()
sharedfile = Sharedfile(source_id=sourcefile.id, name="the name",user_id=self.user.id, \
content_type="image/png", description="description", source_url="https://www.mltshp.com/?hi")
sharedfile.save()
sharedfile.share_key = lib.utilities.base36encode(sharedfile.id)
sharedfile.save()
sharedfile.add_to_shake(s)
#create a shared file video
x = json_encode({
"provider_url":
"https://www.youtube.com/",
"version":
"1.0",
"title":
"YouTube iFrame Embed Option",
"type":
"video",
"thumbnail_width":
480,
"height":
334,
"width":
550,
"html":
"<iframe class=\"youtube-player\" type=\"text/html\" width=\"550\" height=\"334\" src=\"https://www.youtube.com/embed/NtzDtV2Jbk8?rnd=0.277468004525&autoplay=0\" frameborder=\"0\" id=\"ytframe\"></iframe>",
"author_name":
"jameslawsonsmith",
"provider_name":
"YouTube",
"thumbnail_url":
"http://i3.ytimg.com/vi/NtzDtV2Jbk8/hqdefault.jpg",
"thumbnail_height":
360,
"author_url":
"https://www.youtube.com/user/jameslawsonsmith"
})
sourcefile = Sourcefile(width=480,
height=620,
file_key="qwer",
thumb_key="qwer_t",
type="link",
data=x)
sourcefile.save()
sharedfile = Sharedfile(source_id=sourcefile.id, name="another name", user_id=self.user.id, \
content_type="text/html", description="description", source_url="https://www.youtube.com/watch?v=EmcMG4uxiHk")
sharedfile.save()
sharedfile.share_key = lib.utilities.base36encode(sharedfile.id)
sharedfile.save()
sharedfile.add_to_shake(s)
response = self.fetch_url('/shake/yo/rss')
self.assertEqual(response.headers['Content-Type'], 'application/xml')
parsed_xml = lib.utilities.parse_xml(response.body)
self.assertEqual(parsed_xml['rss']['channel']['item']['link'],
'https://mltshp.com/p/1')
class SharedfileModelTests(BaseTestCase):
def setUp(self):
"""
Create a user sourcefile and sharedfile to work with.
"""
super(SharedfileModelTests, self).setUp() # register connection.
self.user = User(name='thename',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
self.user.set_password('pass')
self.user.save()
self.sourcefile = Sourcefile(width=20,height=20,file_key="asdf",thumb_key="asdf_t")
self.sourcefile.save()
self.sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file",user_id=self.user.id, \
content_type="image/png", share_key="1", description="some\ndescription\nhere", source_url="http://www.mltshp.com/?hi")
self.sharedfile.save()
def test_file_size_is_saved_in_newly_uploaded_file(self):
"""
Tests that a brand new file upload saves the file size
"""
file_name = '1.png'
file_content_type = 'image/png'
file_path = os.path.abspath("test/files/1.png")
file_sha1 = Sourcefile.get_sha1_file_key(file_path)
file_size = os.path.getsize(file_path)
sf = Sharedfile.create_from_file(
file_path = file_path,
file_name = file_name,
sha1_value = file_sha1,
content_type = file_content_type,
user_id = self.user.id)
self.assertEqual(sf.size, 69)
def test_file_size_is_not_saved_in_a_simple_share(self):
"""
Tests that just saving a file does not create a file size record
"""
new_user = User(name='newguy',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user.set_password('pass')
new_user.save()
new_sharedfile = self.sharedfile.save_to_shake(new_user)
self.assertEqual(new_sharedfile.size, 0)
def test_attributes_are_saved(self):
"""
Just a test to check that description and source-url are being saved.
"""
sf = Sharedfile.get('id=1')
self.assertEqual(sf.description, "some\ndescription\nhere")
self.assertEqual(sf.source_url, "http://www.mltshp.com/?hi")
def test_can_save(self):
"""
A Sharedfile not owned by the user should be be saveable.
If a Sharedfile already belongs to user, should not be saveable.
Sharedfile.can_save should return False when no user specified.
"""
self.assertFalse(self.sharedfile.can_save(self.user))
user = User(name='newuser',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
user.save()
self.assertTrue(self.sharedfile.can_save(user))
self.assertFalse(self.sharedfile.can_save(None))
self.assertFalse(self.sharedfile.can_save())
def test_can_delete(self):
"""
A Sharedfile should only be deletable if belongs to the user.
Sharedfile.can_delete should return False when no user specified.
"""
new_user = User(name='thename',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user.save()
self.assertEqual(self.user.id, self.sharedfile.user_id)
self.assertTrue(self.sharedfile.can_delete(self.user))
self.assertFalse(self.sharedfile.can_delete(new_user))
self.assertFalse(self.sharedfile.can_delete(None))
self.assertFalse(self.sharedfile.can_delete())
def test_can_favor(self):
"""
A Sharedfile is favorable if it doesn't belong to the user and
it has not been favorited in the past.
Sharedfile.can_save should return False when no user specified.
"""
self.assertFalse(self.sharedfile.can_favor(self.user))
# Create a new shared file that doesn't belong to user.
new_user = User(name='new_email',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user.save()
self.assertTrue(self.sharedfile.can_favor(new_user))
new_user.add_favorite(self.sharedfile)
self.assertFalse(self.sharedfile.can_favor(new_user))
self.assertFalse(self.sharedfile.can_favor(None))
self.assertFalse(self.sharedfile.can_favor())
def test_can_unfavor(self):
"""
Sharedfile.can_unfavor only if the Sharedfile is already favorited.
Should return False if no user is passed in, or never been favorited
in the first place.
"""
# Create a new shared file that doesn't belong to user.
new_user = User(name='new_email',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user.save()
self.assertFalse(self.sharedfile.can_unfavor(new_user))
new_user.add_favorite(self.sharedfile)
self.assertTrue(self.sharedfile.can_unfavor(new_user))
self.assertFalse(self.sharedfile.can_unfavor(None))
self.assertFalse(self.sharedfile.can_unfavor())
def test_can_edit(self):
"""
Sharedfile.can_edit should return True only if Sharedfile belongs to user
Should return false if no user is passed in.
"""
self.assertEqual(self.sharedfile.user_id, self.user.id)
self.assertTrue(self.sharedfile.can_edit(self.user))
new_user = User(name='new_email',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user.save()
self.assertFalse(self.sharedfile.can_edit(new_user))
self.assertFalse(self.sharedfile.can_edit(None))
self.assertFalse(self.sharedfile.can_edit())
def test_save_file_to_user(self):
"""
When saving file to another user, it creates an exact copy of sharedfile with following conditions:
* id, user_id and share_key will be different.
* name, content_type and source_id should be the same.
* parent_id should point to original sharedfile's id
* original_id should point to the shared file id if it was 0 (in this case it is)
* user id of new file should belong to new user.
Returns an instance of the new shared file.
"""
user = User(name='newuser',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
user.save()
new_file = self.sharedfile.save_to_shake(user)
# make sure id is not None, meaning it's saved.
self.assertNotEqual(new_file.id, None)
# id is not the same as old id (pretty impossible)
self.assertNotEqual(new_file.id, self.sharedfile.id)
self.assertNotEqual(new_file.share_key, self.sharedfile.share_key)
# original_id should be the id of the share it was saved from
# since that was the original share
self.assertEqual(new_file.original_id, self.sharedfile.id)
# User id of new file should be user id of user it's saved to.
self.assertEqual(new_file.user_id, user.id)
self.assertEqual(new_file.name, self.sharedfile.name)
self.assertEqual(new_file.content_type, self.sharedfile.content_type)
self.assertEqual(new_file.source_id, self.sharedfile.source_id)
# parent_shared_file_id should point to original
self.assertEqual(new_file.parent_id, self.sharedfile.id)
#final test, a share of a share needs to still point to original_id of the first share
user = User(name='anotheruser',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
user.save()
newer_file = new_file.save_to_shake(user)
self.assertEqual(newer_file.parent_id, new_file.id)
self.assertEqual(newer_file.original_id, self.sharedfile.id)
def test_parent(self):
new_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file",user_id=self.user.id, \
content_type="image/png", share_key="another_share_key", parent_id=self.sharedfile.id)
new_sharedfile.save()
parent = new_sharedfile.parent()
self.assertEqual(parent.id, self.sharedfile.id)
def test_parent_user(self):
"""
Creates new user and sharedfile, pointing to the sharedfile in setUp.
"""
user = User(name='anewusername',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
user.save()
new_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file",user_id=user.id, \
content_type="image/png", share_key="another_share_key", parent_id=self.sharedfile.id)
new_sharedfile.save()
parent_user = new_sharedfile.parent_user()
self.assertEqual(parent_user.id, self.sharedfile.user_id)
def test_source_file(self):
"""
The Sourcefile object returned should match the one we associated.
"""
fetched_sourcefile = self.sharedfile.sourcefile()
self.assertEqual(fetched_sourcefile.id, self.sourcefile.id)
def test_user(self):
"""
The User object returned should match the one we associated.
"""
fetched_user = self.sharedfile.user()
self.assertEqual(fetched_user.id, self.user.id)
def test_get_by_share_key(self):
"""
The Sharedfile object should match the object with the same share_key created in setUp.
"""
fetched_sharedfile = Sharedfile.get_by_share_key("1")
self.assertEqual(fetched_sharedfile.id, self.sharedfile.id)
def test_get_by_share_key_deleted(self):
"""
If sharedfile is deleted should not be returned by get_by_share_key().
"""
self.sharedfile.delete()
fetched_sharedfile = Sharedfile.get_by_share_key("ok")
self.assertEqual(fetched_sharedfile, None)
def test_saving_sets_the_created_and_updated_at(self):
"""
When we saved sharedfile, it's created and updated_at should be set in UTC.
We check the date to make sure it's within last 5 seconds.
"""
created_at = self.sharedfile.created_at
updated_at = self.sharedfile.updated_at
five_seconds = timedelta(seconds=5)
if (datetime.utcnow() - created_at) < five_seconds:
created_at_is_recent = True
else:
created_at_is_recent = False
self.assertTrue(created_at_is_recent)
if (datetime.utcnow() - updated_at) < five_seconds:
modified_at_is_recent = True
else:
modified_at_is_recent = False
self.assertTrue(created_at_is_recent)
def test_incoming(self):
"""
Sharedfile.incoming should return only last 10 added sharedfiles.
"""
# Adding 50 sharedfiles.
for i in range(50):
share_key = "%s" % i
self.sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file",user_id=self.user.id, \
content_type="image/png", share_key=share_key)
self.sharedfile.save()
# should have 26 including file created in setUp.
all_files = Sharedfile.all()
self.assertEqual(len(all_files), 51)
# only returns 10.
incoming = Sharedfile.incoming()
self.assertEqual(len(incoming), 10)
# in order of last added -- biggest id to smallest
last_seen = None
for incoming_file in incoming:
if not last_seen:
last_seen = incoming_file.id
continue
if incoming_file.id < last_seen:
less_then = True
else:
less_then = False
self.assertTrue(less_then)
def test_incoming_doesnt_include_deleted(self):
"""
Sharedfile.incoming should should not return any deleted files.
"""
self.assertEqual(len(Sharedfile.incoming()), 1)
self.sharedfile.delete()
self.assertEqual(len(Sharedfile.incoming()), 0)
def test_incoming_doesnt_include_nsfw_users(self):
"""
Sharedfile.incoming should not return files from users marked nsfw
"""
# Adding 10 sharedfiles.
for i in range(10):
share_key = "%s" % i
self.sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file",user_id=self.user.id, \
content_type="image/png", share_key=share_key)
self.sharedfile.save()
self.user.nsfw = 1
self.user.save()
# should return 0
incoming = Sharedfile.incoming()
self.assertEqual(len(incoming), 0)
self.user.nsfw = 0
self.user.save()
# should return 10
incoming = Sharedfile.incoming()
self.assertEqual(len(incoming), 10)
def test_incoming_includes_nsfw_users_if_asked(self):
"""
Sharedfile.incoming should NOT return files from users marked nsfw if the include_nsfw is True
"""
# Adding 10 sharedfiles.
for i in range(10):
share_key = "%s" % i
self.sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file",user_id=self.user.id, \
content_type="image/png", share_key=share_key)
self.sharedfile.save()
self.user.nsfw = 1
self.user.save()
# should return 10
incoming = Sharedfile.incoming(filter=False)
self.assertEqual(len(incoming), 0)
def test_delete(self):
"""
A regular sharedfile created without deleted parameter specified (as in setUp)
will have that flag set to 0. Calling delete() changes flag to 1 and persists to DB.
"""
self.assertEqual(self.sharedfile.deleted, 0)
self.sharedfile.delete()
self.assertEqual(self.sharedfile.deleted, 1)
fetched_sharedfile = Sharedfile.get("id= %s", self.sharedfile.id)
self.assertEqual(fetched_sharedfile.deleted, 1)
def test_deleting_sharedfile_also_mutes_conversations(self):
new_comment = Comment(user_id=self.user.id, sharedfile_id=self.sharedfile.id)
new_comment.save()
self.sharedfile.delete()
muted_conversation = Conversation.get('user_id=%s and sharedfile_id=%s and muted = 1', self.user.id, self.sharedfile.id)
self.assertTrue(muted_conversation)
def test_sharedfile_from_existing_file(self):
test_files = os.path.join(os.path.dirname(os.path.dirname(__file__)), "files")
file_key = Sourcefile.get_sha1_file_key(test_files + "/1.png")
shutil.copyfile("%s/1.png" % (test_files), "/tmp/%s" % (file_key))
shared_file1 = Sharedfile.create_from_file("/tmp/%s" % (file_key),"1.png", file_key, "image/png", self.user.id)
shared_file2 = Sharedfile.create_from_file("/tmp/%s" % (file_key),"1.png", file_key, "image/png", self.user.id)
self.assertEqual(shared_file1.source_id, shared_file2.source_id)
def test_sharedfile_from_new_file(self):
test_files = os.path.join(os.path.dirname(os.path.dirname(__file__)), "files")
file_key = Sourcefile.get_sha1_file_key(test_files + "/1.png")
shutil.copyfile("%s/1.png" % (test_files), "/tmp/%s" % (file_key))
shared_file = Sharedfile.create_from_file("/tmp/%s" % (file_key),"1.png", file_key, "image/png", self.user.id)
self.assertEqual(shared_file.id, 2)
self.assertEqual(shared_file.source_id, 2)
def test_get_title(self):
"""
If there is no title or title is blank, Sharedfile.get_title should return
the name, otherwise returns title.
if sans_quotes argument set to True, all quotes should be escaped. Off by default
"""
self.assertEqual(self.sharedfile.title, None)
self.assertEqual(self.sharedfile.get_title(), self.sharedfile.name)
self.sharedfile.title = ''
self.sharedfile.save()
self.assertEqual(self.sharedfile.get_title(), self.sharedfile.name)
self.sharedfile.title = 'New title'
self.sharedfile.save()
self.assertEqual(self.sharedfile.get_title(), 'New title')
self.sharedfile.title = 'New "title" and "junk"'
self.assertEqual(self.sharedfile.get_title(), 'New "title" and "junk"')
self.assertEqual(self.sharedfile.get_title(sans_quotes=True), 'New "title" and "junk"')
def test_calculate_view_count(self):
"""
View count should return all views for an image, should not count
user views as equal.
"""
self.assertEqual(0, self.sharedfile.calculate_view_count())
self.sharedfile.add_view()
self.sharedfile.add_view()
self.sharedfile.add_view()
self.sharedfile.add_view(user_id=self.user.id)
self.assertEqual(3, self.sharedfile.calculate_view_count())
def test_save_count(self):
"""
Should return a total count of direct saves of the images, combined with
how many people saved the original (parent) sharedfile.
A = self.sharedfile
self.user = uploads A
new_user = saves A, into B -- A: 1, b: 0
new_user2 = saves B, into C -- A: 2, b: 1, c: 0
new_user3 = saves C, into D -- A: 3, b: 1, c: 1
"""
# Set up users we'll need.
new_user = User(name='new_user',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user.save()
new_user2 = User(name='new_user_2',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user2.save()
new_user3 = User(name='new_user_3',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user3.save()
a = self.sharedfile
self.assertEqual(0, a.save_count())
b = a.save_to_shake(new_user)
self.assertEqual(1, a.save_count())
self.assertEqual(0, b.save_count())
c = b.save_to_shake(new_user2)
self.assertEqual(2, a.save_count())
self.assertEqual(1, b.save_count())
self.assertEqual(0, c.save_count())
d = c.save_to_shake(new_user3)
self.assertEqual(3, a.save_count())
self.assertEqual(1, b.save_count())
self.assertEqual(1, c.save_count())
def test_favorites_for_user(self):
"""
Returns favorites for user, sorted in reverse order of when they were added.
TODO: test the before_id & after_id parameters.
"""
new_user = User(name='new_user',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
new_user.save()
another_sharedfile = Sharedfile(source_id=self.sourcefile.id, name="my shared file",user_id=self.user.id, \
content_type="image/png", share_key="ok", description="some\ndescription\nhere", source_url="http://www.mltshp.com/?hi")
another_sharedfile.save()
#one favorite shared file
new_user.add_favorite(self.sharedfile)
new_user.add_favorite(another_sharedfile)
#this should only return one, since we don't dupe source_ids
sfs = Sharedfile.favorites_for_user(new_user.id)
self.assertEqual(sfs[0].id, self.sharedfile.id)
#but really, underneath we should have two favorites
fs = Favorite.where('user_id = %s', new_user.id)
self.assertEqual(2, len(fs))
def test_sharedfile_saved_to_group_shake(self):
test_files = os.path.join(os.path.dirname(os.path.dirname(__file__)), "files")
file_key = Sourcefile.get_sha1_file_key(test_files + "/1.png")
shutil.copyfile("%s/1.png" % (test_files), "/tmp/%s" % (file_key))
#create a new shake
group_shake = Shake(user_id=self.user.id, type='group', title='asdf', name='asdf')
group_shake.save()
a_shared_file = Sharedfile.create_from_file("/tmp/%s" % (file_key),"1.png", file_key, "image/png", self.user.id, group_shake.id)
self.assertTrue(group_shake.can_update(self.user.id))
a_shared_file.add_to_shake(self.user.shake())
ssfs = Shakesharedfile.all()
for ssf in ssfs:
self.assertEqual(ssf.sharedfile_id, a_shared_file.id)
def test_can_user_delete_from_shake(self):
"""
A user can only delete from a shake if they are the owner of the sharedfile
or the owner of the shake.
"""
user_shake = self.user.shake()
self.sharedfile.add_to_shake(user_shake)
self.assertEqual(True, self.sharedfile.can_user_delete_from_shake(self.user, user_shake))
# A user that doesn't own the sharedfile
new_user = User(name='new_user',email='*****@*****.**',verify_email_token='created', email_confirmed=0)
new_user.save()
self.assertEqual(False, self.sharedfile.can_user_delete_from_shake(new_user, user_shake))
# Owner of a group shake, but file doesn't belong to them.
group_shake = Shake(user_id=new_user.id, type='group', title='Bears', name='bears')
group_shake.save()
self.sharedfile.add_to_shake(group_shake)
self.assertEqual(True, self.sharedfile.can_user_delete_from_shake(new_user, group_shake))
# owner of file, but not of shake.
self.assertEqual(True, self.sharedfile.can_user_delete_from_shake(self.user, group_shake))
def test_delete_from_shake(self):
"""
Deleting a sharedfile from a shake sets the shakesharedfile 'deleted' to 1.
Sharedfile.delete_from_shake retuns True if delete successful or False otherwise.
"""
user_shake = self.user.shake()
self.sharedfile.add_to_shake(user_shake)
ssf = Shakesharedfile.get("sharedfile_id = %s", self.sharedfile.id)
# original file is not deleted
self.assertEqual(ssf.deleted, 0)
# delete should work
self.assertEqual(True, self.sharedfile.delete_from_shake(user_shake))
ssf = Shakesharedfile.get("sharedfile_id = %s", self.sharedfile.id)
self.assertEqual(ssf.deleted, 1)
#def test_favorite_count(self):
# """
# Should return total favorite count for current image. Should not
# count removed favorites.
# """
# self.assertEqual(0, self.sharedfile.favorite_count())
# # Create some users to save images to.
# new_user = User(name='new_user',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
# new_user.save()
# new_user2 = User(name='new_user_2',email='*****@*****.**',verify_email_token='created',email_confirmed=0)
# new_user2.save()
# new_user.add_favorite(self.sharedfile)
# self.assertEqual(1, self.sharedfile.favorite_count())
# new_user2.add_favorite(self.sharedfile)
# self.assertEqual(2, self.sharedfile.favorite_count())
# new_user2.remove_favorite(self.sharedfile)
# self.assertEqual(1, self.sharedfile.favorite_count())
def test_comment_count(self):
"""
Comment count should return the number of comments belonging to
shard file. Should not count deleted comments.
"""
self.assertEqual(0, self.sharedfile.comment_count())
comment = Comment(sharedfile_id=self.sharedfile.id, user_id=self.user.id, body="just a comment")
comment.save()
self.assertEqual(1, self.sharedfile.comment_count())
comment = Comment(sharedfile_id=self.sharedfile.id, user_id=self.user.id, body="just a comment", deleted=True)
comment.save()
self.assertEqual(1, self.sharedfile.comment_count())
def test_set_nsfw(self):
"""
When a user flags an image as NSFW, a new NSFWLog entry is created with
that user's id and sharedfile's id, with current timestamp. The NSFW
flag on the sharedfile's sourcefile also gets flipped to 1.
"""
sourcefile = self.sharedfile.sourcefile()
self.assertEqual(0, self.sourcefile.nsfw)
self.assertEqual(0, len(NSFWLog.all()))
self.sharedfile.set_nsfw(self.user)
fetched_sf = Sharedfile.get("id = %s", self.sharedfile.id)
fetched_source = fetched_sf.sourcefile()
self.assertEqual(1, fetched_source.nsfw)
self.assertEqual(1, len(NSFWLog.all()))
log_entry = NSFWLog.all()[0]
self.assertEqual(self.user.id, log_entry.user_id)
self.assertEqual(self.sharedfile.id, log_entry.sharedfile_id)
self.assertEqual(fetched_source.id, log_entry.sourcefile_id)
self.assertTrue(log_entry.created_at - datetime.utcnow() <= timedelta(seconds=2))
def test_as_json_with_user_context(self):
"""
as_json should return the correct 'saved' and 'liked' flags
if user_context is provided.
"""
new_user = User(name='newuser', email='*****@*****.**', verify_email_token='created', email_confirmed=0)
new_user.save()
sf_dict = self.sharedfile.as_json(user_context=new_user)
self.assertEqual(False, sf_dict['saved'])
self.assertEqual(False, sf_dict['liked'])
self.sharedfile.save_to_shake(new_user)
sf_dict = self.sharedfile.as_json(user_context=new_user)
self.assertEqual(True, sf_dict['saved'])
self.assertEqual(False, sf_dict['liked'])
new_user.add_favorite(self.sharedfile)
sf_dict = self.sharedfile.as_json(user_context=new_user)
self.assertEqual(True, sf_dict['saved'])
self.assertEqual(True, sf_dict['liked'])
def test_likers_list(self):
"""
Tests that likers are returned. Should not include deleted likers.
"""
pass
def test_save_count(self):
"""
Tests that people who saved it are returned. Should not included deleted saves.
"""
pass
def test_tag_search(self):
self.sharedfile.description = """#here #is some #tags that I got for #you.
#here is another word that #is not to be duplicated."""
tags = self.sharedfile.find_tags()
self.assertEqual(tags, set(['is', 'you', 'here', 'tags']))
def test_tags_are_not_too_long(self):
self.sharedfile.description = """#asdfasdfasdfasdfasdf is twenty and
this is 21 #asdfasdfasdfasdfasdfz and this is 22 #asdfasdfasdfasdfasdfxx"""
tags = self.sharedfile.find_tags()
self.assertEqual(tags, set(['asdfasdfasdfasdfasdf']))
def test_tags_dont_find_urls(self):
self.sharedfile.description = """#cool Some descriptions have urls in them like
this one here http://cnn.com/#bad and this
http://www.cnn.com/?canada#worse #great?"""
tags = self.sharedfile.find_tags()
self.assertEqual(tags, set(['cool', 'great']))
def test_tags_dont_include_nonchars(self):
self.sharedfile.description = """#cool-bad #cool-good
#cool #cool?dunno 234238273#238023osidjf waht e#e can I do? i dunno
"""
tags = self.sharedfile.find_tags()
self.assertEqual(tags, set(['cool']))
def test_tags_dont_exist(self):
self.sharedfile.description = """234238273#238023osidjf e#e
https://twitter.com/#!/jJIe
"""
tags = self.sharedfile.find_tags()
self.assertEqual(tags, set([]))
def test_tags_created_on_save(self):
self.sharedfile.description = """#here #is some #tags that I got for #you.
#here is another word that #is not to be duplicated."""
self.sharedfile.save()
tags = Tag.all()
for tag in tags:
self.assertTrue(tag.name in ['is', 'you', 'here', 'tags'])
def test_tags_assigned_on_save(self):
self.sharedfile.description = """#here #is some #tags that I got for #you.
#here is another word that #is not to be duplicated."""
self.sharedfile.save()
tags = self.sharedfile.tags()
for tag in tags:
self.assertTrue(tag.name in ['is', 'you', 'here', 'tags'])
def test_tags_become_deleted_on_overwrite(self):
#create a file with tags
self.sharedfile.description = """#here #is some #tags that I got for #you.
#here is another word that #is not to be duplicated."""
self.sharedfile.save()
#load the file back up and change the description
self.sharedfile = Sharedfile.get("id = %s", self.sharedfile.id)
self.sharedfile.description = "some #all #newtags #not #old"
self.sharedfile.save()
#save the file and check that the new tags are only returned
tags = self.sharedfile.tags()
for tf in tags:
self.assertTrue(tf.name in ['all', 'newtags', 'not', 'old'])
#load the deleted tags and check that they are the same as the original
tagged_files = TaggedFile.where("deleted = 1")
for tf in tagged_files:
t = Tag.get('id = %s', tf.tag_id)
self.assertTrue(t.name in ['here', 'is', 'tags', 'you'])
def test_tags_completely_disappear_on_clearing(self):
#create a new sharedfile
#set the description with tags
self.sharedfile.description = """#here #is some #tags that I got for #you.
#here is another word that #is not to be duplicated."""
self.sharedfile.save()
#set a new description that has no tags
self.sharedfile.description = "I have no tags."
self.sharedfile.save()
#verify tags() is empty.
tags = self.sharedfile.tags()
self.assertEqual(tags, [])
#verify the original tags are all deleted=1
tagged_files = TaggedFile.all()
for tf in tagged_files:
self.assertEqual(tf.deleted, 1)
def test_tags_with_numbers_are_created(self):
self.sharedfile.description = """#here1 #is2 some #tags3 that I got for #you4.
#here1 is another word that #is2 not to be duplicated."""
self.sharedfile.save()
tags = self.sharedfile.tags()
for tag in tags:
self.assertTrue(tag.name in ['is2', 'you4', 'here1', 'tags3'])
def test_tags_with_different_case(self):
self.sharedfile.description = """This #TAG should only appear #tag once in
this #tAg list and also #YES1YES #yes1yes."""
self.sharedfile.save()
tags = self.sharedfile.tags()
for tag in tags:
self.assertTrue(tag.name in ['tag', 'yes1yes'])
def test_saving_a_file_from_someone_doesnt_run_tagging(self):
self.sharedfile.description = """This #TAG should only appear #tag once in
this #tAg list and also #YES1YES #yes1yes."""
self.sharedfile.save(ignore_tags=True)
self.assertEqual([], self.sharedfile.tags())
def test_deleting_shared_file_deletes_tags(self):
self.sharedfile.description = """#here1 #is2 some #tags3 that I got for #you4.
#here1 is another word that #is2 not to be duplicated."""
self.sharedfile.save()
self.sharedfile.delete()
tf = TaggedFile.all()
for t in tf:
self.assertEqual(t.deleted, 1)
def on_thumbnail_response(self, response):
if response.code != 200:
self.render(
"tools/save-video-error.html",
message=
"We could not load the thumbnail for this file and therefore could not save this video. Please contact support."
)
return
#if the thumbnail url needs to be extracted (Flickr) let's see if
# we got back HTML that points to the thumbnail
if self.oembed_doc['provider_name'] == "Flickr" and response.headers[
'Content-Type'] == 'text/html; charset=utf-8':
#if we're here, that means we need to extract the thumbnail and make a call to the actual jpg
s = re.search(
'<link rel="image_src" href="http://farm(\d).static.flickr.com/(\d+)/(\d+)_([a-zA-Z0-9]+)_m.jpg">',
response.body)
try:
if s and s.group(0) and s.group(1) and s.group(2) and s.group(
3) and s.group(4):
self.oembed_doc[
'thumbnail_url'] = "http://farm%s.static.flickr.com/%s/%s_%s_b.jpg" % (
s.group(1), s.group(2), s.group(3), s.group(4))
request = HTTPRequest(self.oembed_doc['thumbnail_url'],
'GET')
http = tornado.httpclient.AsyncHTTPClient()
http.fetch(request, self.on_thumbnail_response)
except:
self.render(
"tools/save-video-error.html",
message=
"We could not load the thumbnail for this file and therefore could not save this video. Please contact support."
)
return
elif self.oembed_doc['provider_name'] == "Vine" and response.headers[
'Content-Type'] == 'text/html; charset=utf-8':
# if we're here, that means we need to extract the thumbnail and make a call to the actual jpg
# use BeautfilSoup to parse for the title and meta tag. We'll do this bit of danger in a
# try block and shrug if something bad happens
try:
soup = BeautifulSoup(
response.body, convertEntities=BeautifulSoup.HTML_ENTITIES)
self.oembed_doc['title'] = soup.title.text
thumbnail = soup.find('meta', {"property": "og:image"})
if thumbnail:
self.oembed_doc['thumbnail_url'] = thumbnail.attrMap[
'content']
request = HTTPRequest(self.oembed_doc['thumbnail_url'],
'GET')
http = tornado.httpclient.AsyncHTTPClient()
http.fetch(request, self.on_thumbnail_response)
return
except:
pass
# either we failed to find a thumbnail url, or an exception was raised
# while attempting to fetch.
self.render(
"tools/save-video-error.html",
message=
"We could not load the thumbnail for this file and therefore could not save this video. Please contact support."
)
else:
# save the response
url = self.get_argument('url')
current_user = self.get_current_user_object()
sha1_key = Sourcefile.get_sha1_file_key(file_path=None,
file_data=url)
thumbnail_path = "%s/%s" % (options.uploaded_files, sha1_key)
fh = open(thumbnail_path, 'wb')
fh.write(response.body)
fh.close()
source_file = Sourcefile.create_from_json_oembed(
link=url,
oembed_doc=self.oembed_doc,
thumbnail_file_path=thumbnail_path)
#cleanup
if not options.debug:
try:
os.remove(thumbnail_path)
except:
pass
title = ''
if self.oembed_doc.has_key('title'):
title = self.oembed_doc['title']
shared_file = Sharedfile(user_id=current_user.id,
name=url,
content_type='text/html',
source_id=source_file.id,
title=title,
source_url=url)
shared_file.save()
share_key = base36encode(shared_file.id)
shared_file.share_key = share_key
shared_file.save()
user_shake = Shake.get('user_id = %s and type=%s', current_user.id,
'user')
shared_file.add_to_shake(self.destination_shake)
if self.oembed_doc.has_key('description'):
shared_file.description = self.oembed_doc['description']
self.write({'path': "/p/%s" % (share_key)})
self.finish()