def setUp(self):
self.ae = MockAppEngine()
self.user = self.ae.get_current_user()
self.db = MockAccess(user=self.user, add_owner=self.is_user_owner())
# set up mock Request and Response objects
self.request = mock.MagicMock()
self.response = mock.MagicMock()
# Create a special SpyResource class that has all the same
# functionality as the appropriate Resource for this test, but
# has a fake 'dump' method which stores the last js_object dumped
resource_cls = self.get_resource_cls()
class SpyResource(resource_cls):
def __init__(self, *args, **kwargs):
super(SpyResource, self).__init__(*args, **kwargs)
self.last_response = None
def get_last_response(self):
return self.last_response
def dump(self, js_response):
self.last_response = js_response
# instantiate the SpyResource with fake Request/Response as well as
# AppEngine and DbAccess
self.resource = SpyResource(
request=self.request,
response=self.response,
ae=self.ae,
db=self.db,
)
def setUp(self):
self.db = MockAccess(User(), add_owner=True)
self.ae = MockWrapper()
self.rpc = ListRpcGroup(self.db, self.ae)
class ListRpcTest(unittest.TestCase):
def setUp(self):
self.db = MockAccess(User(), add_owner=True)
self.ae = MockWrapper()
self.rpc = ListRpcGroup(self.db, self.ae)
def set_user(self, user):
self.db.user = user
def set_owner(self, owner):
self.db.owner = owner
self.db.user = owner.user
def delete_owner(self):
oid = self.db.owner.key().id()
self.db.delete(self.db.owner)
self.db.owner = None
return oid
def create_group(self, created_by, members, name='Group', desc='Desc'):
g = self.db.add_group(name, desc, created_by)
[self.db.add_group_member(g, o) for o in members]
return g
def create_list(self, oid, idx, count):
_ = lambda x: '{} {}'.format(x, idx)
wl = self.db.add_list(oid, _('List'), _('List Desc'))
lid = wl.key().id()
for idx in xrange(count):
self.db.add_list_item(lid, _('Item'), _('Cat'), _('Desc'),
_('url'), idx % 2 == 0)
def create_lists(self, owner, count):
oid = owner.key().id()
for i in xrange(count):
self.create_list(oid, i, 2 * i)
def compare_all_lists(self, lists, wlists):
self.assertEqual(len(lists), len(wlists))
for l, wl in zip(lists, wlists):
self.compare_lists(l, wl)
def compare_lists(self, l, wl):
l_items, wl_items = (l.items, wl.items)
self.assertEqual(len(l_items), len(wl_items))
for item, witem in zip(l_items, wl_items):
self.compare_items(item, witem)
def compare_items(self, item, witem):
ga, eq = (getattr, self.assertEqual)
_ = lambda x: x.label() if x is not None else ''
attrs = ('name', 'category', 'description', 'url', 'is_surprise')
[eq(ga(item, a), ga(witem, a)) for a in attrs]
eq(_(item.purchased_by), witem.purchased_by)
eq(_(item.reserved_by), witem.reserved_by)
def test_add_list(self):
'''
Confirm that add_list actually adds a list
'''
oid = self.db.owner.key().id()
self.rpc.add_list(oid, 'List Name', 'List Desc')
self.assertEqual(1, len(self.db.lists))
l = self.db.lists.values()[0]
self.assertTrue(l.key().id() in range(1, 1001))
self.assertEqual('List Name', l.name)
self.assertEqual('List Desc', l.description)
def test_add_list_no_owner(self):
'''
Confirm that trying to add a list with no owner raises a
PermissionDeniedError
'''
oid = self.delete_owner()
with self.assertRaises(PermissionDeniedError):
self.rpc.add_list(oid, 'Name', 'Desc')
def test_add_list_other_owner(self):
'''
Confirm that trying to add a list for another owner raises a
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
oid = o.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.add_list(oid, 'Name', 'Desc')
def test_add_list_duplicate_name(self):
'''
Confirm that trying to add a list with a duplicate name raises
a DuplicateNameError
'''
oid = self.db.owner.key().id()
name = 'My Wish List'
self.db.add_list(oid, name, 'Description')
with self.assertRaises(DuplicateNameError):
self.rpc.add_list(oid, name, 'Another List Description')
def test_update_list(self):
'''
Confirm that update_list actually updates a list
'''
oid = self.db.owner.key().id()
l = self.db.add_list(oid, 'Name', 'Description')
lid = l.key().id()
self.rpc.update_list(lid, 'New Name', 'New Desc')
self.assertEqual(1, len(self.db.lists))
l = self.db.lists.values()[0]
self.assertEqual('New Name', l.name)
self.assertEqual('New Desc', l.description)
def test_update_list_no_owner(self):
'''
Confirm that trying to update a list with no owner raises a
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
l = self.db.add_list(o.key().id(), 'List Name', 'List Desc')
lid = l.key().id()
self.delete_owner()
with self.assertRaises(PermissionDeniedError):
self.rpc.update_list(lid, 'Name', 'Desc')
def test_update_list_invalid_owner(self):
'''
Confirm that trying to add a list for an invalid owner raises a
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
oid = o.key().id()
l = self.db.add_list(oid, 'New List', 'New Desc')
lid = l.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.update_list(lid, 'Name', 'Desc')
def test_update_list_duplicate_name(self):
'''
Confirm that trying to update a list with a duplicate name raises
a DuplicateNameError
'''
oid = self.db.owner.key().id()
name = 'My Wish List'
self.db.add_list(oid, name, 'Description')
l = self.db.add_list(oid, 'Second Name', 'Second Description')
lid = l.key().id()
with self.assertRaises(DuplicateNameError):
self.rpc.update_list(lid, name, 'Another List Description')
def test_get_list_no_owner(self):
'''
Confirm that trying to get lists with no owner raises a
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
oid = o.key().id()
self.delete_owner()
with self.assertRaises(PermissionDeniedError):
self.rpc.get_lists(oid)
def test_get_lists_invalid_owner(self):
'''
Confirm that trying to get lists for an invalid owner raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
oid = o.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.get_lists(oid)
def test_get_own_lists(self):
'''
Confirm that get_lists works for current owner
'''
oid = self.db.owner.key().id()
def _add(i):
return self.db.add_list(oid, 'List {}'.format(i),
'Desc {}'.format(i))
lists = [_add(i) for i in '12345']
wls = self.rpc.get_lists(oid)
self.assertEqual(len(lists), len(wls))
def test_get_lists_from_member_of_my_group(self):
'''
Confirm that get_lists works for an owner who is a member of
a group owned by current owner
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(self.db.owner, [o])
oid = o.key().id()
wls = self.rpc.get_lists(oid)
self.compare_all_lists(o.lists, wls)
def test_get_lists_from_member_of_group_im_in(self):
'''
Confirm that get_lists works for an owner who is a member of
a group current owner is also in
'''
o1 = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o1, 5)
self.create_group(o2, [o1, self.db.owner])
oid = o1.key().id()
wls = self.rpc.get_lists(oid)
self.compare_all_lists(o1.lists, wls)
pass
def test_get_lists_from_owner_of_group_im_in(self):
'''
Confirm that get_lists works for an owner who is the owner of
a group current owner is in
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
oid = o.key().id()
wls = self.rpc.get_lists(oid)
self.compare_all_lists(o.lists, wls)
def test_add_item_to_invalid_owner(self):
'''
Confirm that trying to add an item to the list of an invalid owner
raises PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
lid = o.lists[0].key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.add_item(lid, 'item', 'cat', 'desc', 'url', False)
def test_add_surprise_item_to_invalid_owner(self):
'''
Confirm that trying to add a surprise item to the list of an invalid
owner raises PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
lid = o.lists[0].key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.add_item(lid, 'item', 'cat', 'desc', 'url', True)
def test_add_surprise_item_for_fellow_group_memeber(self):
'''
Confirm ability to add a surprise item to a list you have access to
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
l = o.lists[2]
count = len(l.items)
lid = l.key().id()
w_list = self.rpc.add_item(lid, 'item', 'cat', 'desc', 'url', True)
witem = w_list.items[-1]
self.assertEqual(count + 1, len(o.lists[2].items))
self.assertEqual('item', witem.name)
self.assertEqual('cat', witem.category)
self.assertEqual('desc', witem.description)
self.assertEqual('url', witem.url)
self.assertEqual(True, witem.is_surprise)
self.assertEqual(self.db.owner.nickname, witem.reserved_by)
def test_add_item_to_own_list(self):
'''
Confirm ability to add an item to your own list
'''
self.create_lists(self.db.owner, 1)
l = self.db.owner.lists[0]
count = len(l.items)
lid = l.key().id()
w_list = self.rpc.add_item(lid, 'item', 'cat', 'desc', 'url', False)
witem = w_list.items[0]
self.assertEqual(count + 1, len(self.db.owner.lists[0].items))
self.assertEqual('item', witem.name)
self.assertEqual('cat', witem.category)
self.assertEqual('desc', witem.description)
self.assertEqual('url', witem.url)
self.assertEqual(False, witem.is_surprise)
self.assertEqual('', witem.reserved_by)
self.assertEqual('', witem.purchased_by)
def test_update_item_in_own_list(self):
'''
Confirm ability to update an existing item in your own list
'''
self.create_lists(self.db.owner, 2)
l = self.db.owner.lists[1]
count = len(l.items)
item = l.items[0]
iid = item.key().id()
n, c, d, u = ('New Name', 'New Cat', 'New Desc', 'New URL')
w_list = self.rpc.update_item(iid, n, c, d, u)
witem = w_list.items[0]
self.assertEqual(count, len(self.db.owner.lists[1].items))
self.assertEqual(n, witem.name)
self.assertEqual(c, witem.category)
self.assertEqual(d, witem.description)
self.assertEqual(u, witem.url)
def test_update_item_in_invalid_list(self):
''''
Confirm that trying to update an item in someone else's list
raises PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.update_item(iid, 'item', 'cat', 'desc', 'url')
def test_remove_item_from_own_list(self):
'''
Confirm ability to remove an item from your own list
'''
self.create_lists(self.db.owner, 5)
l = self.db.owner.lists[3]
count = len(l.items)
item = l.items[0]
iid = item.key().id()
self.rpc.remove_item(iid)
self.assertEqual(count - 1, len(self.db.owner.lists[3].items))
self.assertTrue(item not in self.db.owner.lists[3].items)
def test_remove_reserved_item_from_own_list(self):
'''
Confirm ability to remove an item from your own list
which has previously been marked as reserved, and that an
email is sent to the reserver
'''
self.create_lists(self.db.owner, 5)
l = self.db.owner.lists[-1]
count = len(l.items)
item = l.items[0]
iid = item.key().id()
o = self.db.add_owner(User('foo', '*****@*****.**'))
item.reserved_by = o
item.put()
self.rpc.remove_item(iid)
self.assertEqual(count - 1, len(self.db.owner.lists[-1].items))
owner = self.db.owner
subject = 'Wish List Item Deleted'
template_tuple = (
item.reserved_by.nickname,
owner.nickname,
owner.email,
item.name,
l.name,
'Reserved',
owner.nickname,
owner.email,
)
body = self.ae.DELETED_ITEM_TEMPLATE % template_tuple
msg = dict(f=self.ae.FROM_ADDRESS, t=o.email, s=subject, b=body)
self.assertEqual(msg, self.ae.msg)
def test_remove_purchased_item_from_own_list(self):
'''
Confirm ability to remove an item from your own list
which has previously been marked as purchased, and that an
email is sent to the purchaser
'''
self.create_lists(self.db.owner, 5)
l = self.db.owner.lists[-1]
count = len(l.items)
item = l.items[0]
iid = item.key().id()
o = self.db.add_owner(User('foo', '*****@*****.**'))
item.purchased_by = o
item.put()
self.rpc.remove_item(iid)
self.assertEqual(count - 1, len(self.db.owner.lists[-1].items))
owner = self.db.owner
subject = 'Wish List Item Deleted'
template_tuple = (
item.purchased_by.nickname,
owner.nickname,
owner.email,
item.name,
l.name,
'Purchased',
owner.nickname,
owner.email,
)
body = self.ae.DELETED_ITEM_TEMPLATE % template_tuple
msg = dict(f=self.ae.FROM_ADDRESS, t=o.email, s=subject, b=body)
self.assertEqual(msg, self.ae.msg)
def test_remove_item_from_invalid_list(self):
'''
Confirm that trying to remove an item from someone else's
list raises PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
iid = o.lists[2].items[1].key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.remove_item(iid)
def test_reserve_item(self):
'''
Confirm ability to reserve an item from list you can access
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
self.assertEqual(None, item.reserved_by)
self.assertEqual(None, item.purchased_by)
self.rpc.reserve_item(iid)
self.assertEqual(self.db.owner, item.reserved_by)
self.assertEqual(None, item.purchased_by)
def test_reserve_reserved_item(self):
'''
Confirm trying to reserve a reserved item raises UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.reserved_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.reserve_item(iid)
def test_reserve_puchased_item(self):
'''
Confirm trying to reserve a purchased item raises UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.purchased_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.reserve_item(iid)
def test_unreserve_item(self):
'''
Confirm ability to unreserve and item previously reserved by you
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
item.reserved_by = self.db.owner
item.put()
iid = item.key().id()
self.assertEqual(self.db.owner, item.reserved_by)
self.assertEqual(None, item.purchased_by)
self.rpc.unreserve_item(iid)
self.assertEqual(None, item.reserved_by)
self.assertEqual(None, item.purchased_by)
def test_unreserve_item_not_reserved_by_you(self):
'''
Confirm that trying to unrserve an item reserved by someone else
raises a UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.reserved_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.unreserve_item(iid)
def test_reserve_invalid_item(self):
'''
Confirm trying to reserve an item you don't have access to raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.reserve_item(iid)
def test_unreserve_invalid_item(self):
'''
Confirm trying to unreserve an item you don't have access to raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.unreserve_item(iid)
def test_purchase_item(self):
'''
Confirm ability to purchase an item from list you can access
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
self.assertEqual(None, item.reserved_by)
self.assertEqual(None, item.purchased_by)
self.rpc.purchase_item(iid)
self.assertEqual(None, item.reserved_by)
self.assertEqual(self.db.owner, item.purchased_by)
def test_purchase_reserved_item(self):
'''
Confirm trying to purchase a reserved item raises UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.reserved_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.purchase_item(iid)
def test_purchase_puchased_item(self):
'''
Confirm trying to purchase a purchased item raises UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.purchased_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.purchase_item(iid)
def test_purchase_invalid_item(self):
'''
Confirm trying to purchase an item you don't have access to raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.purchase_item(iid)
def test_unpurchase_invalid_item(self):
'''
Confirm trying to unpurchase an item you don't have access to raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.unpurchase_item(iid)
def test_unpurchase_item(self):
'''
Confirm ability to unpurchase an item you previously purchased
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
item.purchased_by = self.db.owner
item.put()
iid = item.key().id()
self.assertEqual(None, item.reserved_by)
self.assertEqual(self.db.owner, item.purchased_by)
self.rpc.unpurchase_item(iid)
self.assertEqual(None, item.reserved_by)
self.assertEqual(None, item.purchased_by)
def test_unpurchase_item_purchased_by_someone_else(self):
'''
Confirm trying to unpurchase an item purchased by someone else
raises a UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.purchased_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.unpurchase_item(iid)
def setUp(self):
self.db = MockAccess(User(), add_owner=True)
self.ae = MockAppEngine()
self.rpc = GroupRpcGroup(self.db, self.ae)
class GroupRpcTest(unittest.TestCase):
def setUp(self):
self.db = MockAccess(User(), add_owner=True)
self.ae = MockAppEngine()
self.rpc = GroupRpcGroup(self.db, self.ae)
def set_user(self, user):
self.db.user = user
def set_owner(self, owner):
self.db.owner = owner
self.db.user = owner.user
def add_groups(self, count, include_invites=False):
for i in xrange(1, count + 1):
g = self.db.add_group('Name {}'.format(i), 'Desc {}'.format(i))
self.assertEqual([], g.invitations)
self.assertEqual([], g.members)
if include_invites:
self.db.add_group_invite(g, 'email_{}@domain.com'.format(i))
def compare_group(self, db, group):
self.assertEqual(db.key().id(), group.id)
self.assertEqual(db.name, group.name)
self.assertEqual(db.description, group.description)
def setup_groups(self):
O = self.db.add_owner
self.a1 = O(User('a1', '*****@*****.**', is_admin=True))
self.a2 = O(User('a2', '*****@*****.**', is_admin=True))
self.u1 = O(User('u1', '*****@*****.**'))
self.u2 = O(User('u2', '*****@*****.**'))
self.u3 = O(User('u3', '*****@*****.**'))
self.g1 = self.db.add_group('g1', 'g1desc', self.a1)
self.g2 = self.db.add_group('g2', 'g1desc', self.a2)
self.db.add_group_member(self.g1, self.a1)
self.db.add_group_member(self.g1, self.u1)
self.db.add_group_member(self.g1, self.u3)
self.db.add_group_member(self.g2, self.a2)
self.db.add_group_member(self.g2, self.u2)
self.db.add_group_member(self.g2, self.u3)
def Xtest_add_group(self):
"""
Confirm that add_group actually adds a group
"""
self.db.user.is_admin = True
self.rpc.add_group('Group Name', 'Group Desc')
self.assertEqual(1, len(self.db.groups))
g = self.db.groups.values()[0]
self.assertTrue(g.key().id() in range(1, 1001))
self.assertEqual('Group Name', g.name)
self.assertEqual('Group Desc', g.description)
def Xtest_add_group_requires_admin(self):
"""
Confirm trying to add group with non admin user raised Exception
"""
with self.assertRaises(UserVisibleError):
self.rpc.add_group('Name', 'Desc')
def Xtest_add_group_duplicate_name(self):
"""
Confirm that trying to add a group with a duplicate name raises
a DuplicateNameError
"""
self.db.user.is_admin = True
self.add_groups(1)
name = self.db.groups.values()[0].name
with self.assertRaises(DuplicateNameError):
self.rpc.add_group(name, 'Group Desc')
def Xtest_get_groups(self):
"""
Confirm group retrieval
"""
self.add_groups(5)
groups = self.rpc.get_groups()
self.assertEqual(5, len(groups))
for g, group in zip(self.db.get_groups(), groups):
self.compare_group(g, group)
def Xtest_update_group(self):
"""
Confirm ability to change group name/desc
"""
self.add_groups(1)
id = self.db.group_ids[0]
self.rpc.update_group(id, 'New Name', 'New Desc')
g = self.db.get_group(id)
self.assertEqual('New Name', g.name)
self.assertEqual('New Desc', g.description)
def Xtest_update_group_duplicate_name(self):
"""
Confirm that trying to update a group with a used name raises a
DuplicateNameError
"""
self.add_groups(2)
id = self.db.group_ids[0]
name = self.db.get_group(self.db.group_ids[1]).name
with self.assertRaises(DuplicateNameError):
self.rpc.update_group(id, name, 'New Desc')
def Xtest_update_group_same_name(self):
"""
Confirm that trying to update a group with its own name and a new
description does NOT raise a DuplicateNameError
"""
self.add_groups(1)
g = self.db.groups.values()[0]
self.rpc.update_group(g.key().id(), g.name, 'New Desc')
def Xtest_invite_member(self):
"""
Confirm ability to invite someone to a group
"""
self.add_groups(1)
id = self.db.group_ids[0]
group = self.db.groups[id]
self.assertEqual(0, len(group.invitations))
self.rpc.invite_member(id, '*****@*****.**')
self.assertEqual(1, len(group.invitations))
invite = group.invitations[0]
self.assertEqual('*****@*****.**', invite.email)
def Xtest_accept_invitation(self):
"""
Confirm ability to accept a group invite
"""
self.add_groups(1, include_invites=True)
invite = self.db.invitations.values()[0]
group = invite.group
num_invites = len(group.invitations)
self.rpc.accept_invitation(invite.key().id())
self.assertEqual(num_invites - 1, len(group.invitations))
self.assertEqual(1, len(group.members))
self.assertEqual(self.db.owner, group.members[0].member)
def Xtest_decline_invitation(self):
"""
Confirm ability to decline a group invitation
"""
self.add_groups(1, include_invites=True)
invite = self.db.invitations.values()[0]
group = invite.group
num_invites = len(group.invitations)
num_members = len(group.members)
self.rpc.decline_invitation(invite.key().id())
self.assertEqual(num_invites - 1, len(group.invitations))
self.assertEqual(num_members, len(group.members))
self.assertTrue(invite not in self.db.invitations.values())
def test_get_available_owners_a1(self):
"""
Confirm lookup of all available users for a1 owner
"""
self.setup_groups()
self.set_owner(self.a1)
owners = self.rpc.get_available_owners(self.a1.key().id())
self.assertEqual(3, len(owners))
expected = set((o.email for o in (self.a1, self.u1, self.u3)))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def test_get_available_owners_a2(self):
"""
Confirm lookup of all available users for a2 owner
"""
self.setup_groups()
self.set_owner(self.a2)
owners = self.rpc.get_available_owners(self.a2.key().id())
self.assertEqual(3, len(owners))
expected = set((o.email for o in (self.a2, self.u2, self.u3)))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def test_get_available_owners_u1(self):
"""
Confirm lookup of all available users for u1 owner
"""
self.setup_groups()
self.set_owner(self.u1)
owners = self.rpc.get_available_owners(self.u1.key().id())
self.assertEqual(3, len(owners))
expected = set((o.email for o in (self.a1, self.u1, self.u3)))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def test_get_available_owners_u2(self):
"""
Confirm lookup of all available users for u2 owner
"""
self.setup_groups()
self.set_owner(self.u2)
owners = self.rpc.get_available_owners(self.u2.key().id())
self.assertEqual(3, len(owners))
expected = set((o.email for o in (self.a2, self.u2, self.u3)))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def test_get_available_owners_u3(self):
"""
Confirm lookup of all available users for u3 owner
"""
self.setup_groups()
self.set_owner(self.u3)
owners = self.rpc.get_available_owners(self.u3.key().id())
self.assertEqual(5, len(owners))
all = (self.a1, self.a2, self.u1, self.u2, self.u3)
expected = set((o.email for o in all))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def set_user(self, user):
self.user = user
self.db = MockAccess(self.user)
self.ae = MockAppEngine()
self.rpc = UserRpcGroup(self.db, self.ae)
class UserRpcTest(unittest.TestCase):
def setUp(self):
self.set_user(User())
def set_user(self, user):
self.user = user
self.db = MockAccess(self.user)
self.ae = MockAppEngine()
self.rpc = UserRpcGroup(self.db, self.ae)
def Xtest_get_user_none(self):
"""
Verify that calling get_current_user without being logged in
provides you with a login url
"""
# Start with no user logged in
self.set_user(None)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify nothing but login url is returned
self.assertEqual(None, user.logout_url)
self.assertEqual(None, user.email)
self.assertEqual(None, user.user_id)
self.assertEqual(None, user.nickname)
login_url = self.ae.create_login_url(url)
self.assertEqual(login_url, user.login_url)
def Xtest_get_user(self):
"""
Verify that calling get_current_user while logged in provides you
with a logout url and your login info
"""
self.set_user(User(is_admin=True))
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
base = get_base_url(url)
goodbye = '{}/#Goodbye:'.format(base)
self.assertEqual(self.ae.create_logout_url(goodbye), user.logout_url)
self.assertEqual(self.user.nickname(), user.nickname)
self.assertEqual(self.user.email(), user.email)
self.assertEqual(None, user.login_url)
# Verify owner was created correctly
owner = self.db.user_owners.get(self.user)
self.assertEqual(num_owners + 1, len(self.db.owners))
self.assertEqual(self.user, owner.user)
self.assertEqual(owner.key().id(), user.owner_id)
self.assertEqual(self.user.nickname(), owner.nickname)
self.assertEqual(self.user.email(), owner.email)
self.assertEqual(extract_name(self.user.email()), owner.name)
def Xtest_get_user_owner_exists(self):
"""
Verify that a duplicate owner is not created when get_current_user
is called
"""
# Make sure owner exists before call
owner = self.db.add_owner(self.user)
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# verify still the same owner after the call
self.assertEqual(num_owners, len(self.db.owners))
self.assertEqual(owner.key().id(), user.owner_id)
self.assertEqual(owner, self.db.user_owners[self.user])
def Xtest_get_user_add_req(self):
"""
Verify that when non-admin user tries to log in, an Access Request is
created for them.
"""
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
base = get_base_url(url)
goodbye = '{}/#Goodbye:'.format(base)
self.assertEqual(self.ae.create_logout_url(goodbye), user.logout_url)
self.assertEqual(self.user.nickname(), user.nickname)
self.assertEqual(self.user.email(), user.email)
self.assertEqual(None, user.login_url)
self.assertEqual(-1, user.owner_id)
self.assertEqual(num_owners, len(self.db.owners))
# Verify access request was created correctly
self.assertEqual(1, len(self.db.request_ids))
req = self.db.requests.values()[0]
self.assertEqual(self.user, req.user)
def Xtest_get_user_req_exists(self):
"""
Verify that the second time get_current_user is called, a second
AccessRequest is not created.
"""
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
# Create the request that already exists
self.db.add_req(self.user)
self.assertEqual(1, len(self.db.request_ids))
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
self.assertEqual(None, user.login_url)
self.assertEqual(-1, user.owner_id)
self.assertEqual(num_owners, len(self.db.owners))
# Verify no additional request was created correctly
self.assertEqual(1, len(self.db.request_ids))
def Xtest_get_owner(self):
"""
Verify ability to lookup owner by id
"""
# Make sure the owner exists
owner = self.db.add_owner(self.user)
oid = owner.key().id()
lo = self.rpc.get_owner(oid)
self.assertEqual(oid, lo.id)
self.assertEqual(owner.email, lo.email)
self.assertEqual(owner.nickname, lo.nickname)
self.assertEqual(owner.name, lo.name)
def test_update_owner(self):
"""
Make sure user can change name and nickname of list owner
"""
# Make sure the owner exists
self.set_user(User('John Doe', 'Johnny'))
self.db.add_owner(self.user)
owner = self.db.add_owner(self.user)
self.assertFalse(owner.saved())
self.rpc.update_owner(owner.key().id(), 'Joe Smith', 'Joe')
self.assertTrue(owner.saved())
self.assertEqual('Joe Smith', owner.name)
self.assertEqual('Joe', owner.nickname)
class UserRpcTest(unittest.TestCase):
def setUp(self):
self.set_user(User())
def set_user(self, user):
self.user = user
self.db = MockAccess(self.user)
self.ae = MockWrapper()
self.rpc = UserRpcGroup(self.db, self.ae)
def test_get_user_none(self):
'''
Verify that calling get_current_user without being logged in
provides you with a login url
'''
# Start with no user logged in
self.set_user(None)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify nothing but login url is returned
self.assertEqual(None, user.logout_url)
self.assertEqual(None, user.email)
self.assertEqual(None, user.user_id)
self.assertEqual(None, user.nickname)
login_url = self.ae.create_login_url(url)
self.assertEqual(login_url, user.login_url)
def test_get_user(self):
'''
Verify that calling get_current_user while logged in provides you
with a logout url and your login info
'''
self.set_user(User(is_admin=True))
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
base = get_base_url(url)
goodbye = '{}/#Goodbye:'.format(base)
self.assertEqual(self.ae.create_logout_url(goodbye), user.logout_url)
self.assertEqual(self.user.nickname(), user.nickname)
self.assertEqual(self.user.email(), user.email)
self.assertEqual(None, user.login_url)
# Verify owner was created correctly
owner = self.db.user_owners.get(self.user)
self.assertEqual(num_owners + 1, len(self.db.owners))
self.assertEqual(self.user, owner.user)
self.assertEqual(owner.key().id(), user.owner_id)
self.assertEqual(self.user.nickname(), owner.nickname)
self.assertEqual(self.user.email(), owner.email)
self.assertEqual(extract_name(self.user.email()), owner.name)
def test_get_user_owner_exists(self):
'''
Verify that a duplicate owner is not created when get_current_user
is called
'''
# Make sure owner exists before call
owner = self.db.add_owner(self.user)
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# verify still the same owner after the call
self.assertEqual(num_owners, len(self.db.owners))
self.assertEqual(owner.key().id(), user.owner_id)
self.assertEqual(owner, self.db.user_owners[self.user])
def test_get_user_add_req(self):
'''
Verify that when non-admin user tries to log in, an Access Request is
created for them.
'''
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
base = get_base_url(url)
goodbye = '{}/#Goodbye:'.format(base)
self.assertEqual(self.ae.create_logout_url(goodbye), user.logout_url)
self.assertEqual(self.user.nickname(), user.nickname)
self.assertEqual(self.user.email(), user.email)
self.assertEqual(None, user.login_url)
self.assertEqual(-1, user.owner_id)
self.assertEqual(num_owners, len(self.db.owners))
# Verify access request was created correctly
self.assertEqual(1, len(self.db.request_ids))
req = self.db.requests.values()[0]
self.assertEqual(self.user, req.user)
def test_get_user_req_exists(self):
'''
Verify that the second time get_current_user is called, a second
AccessRequest is not created.
'''
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
# Create the request that already exists
self.db.add_req(self.user)
self.assertEqual(1, len(self.db.request_ids))
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
self.assertEqual(None, user.login_url)
self.assertEqual(-1, user.owner_id)
self.assertEqual(num_owners, len(self.db.owners))
# Verify no additional request was created correctly
self.assertEqual(1, len(self.db.request_ids))
def test_get_owner(self):
'''
Verify ability to lookup owner by id
'''
# Make sure the owner exists
owner = self.db.add_owner(self.user)
oid = owner.key().id()
lo = self.rpc.get_owner(oid)
self.assertEqual(oid, lo.id)
self.assertEqual(owner.email, lo.email)
self.assertEqual(owner.nickname, lo.nickname)
self.assertEqual(owner.name, lo.name)
def test_update_owner(self):
'''
Make sure user can change name and nickname of list owner
'''
# Make sure the owner exists
self.set_user(User('John Doe', 'Johnny'))
self.db.add_owner(self.user)
owner = self.db.add_owner(self.user)
self.assertFalse(owner.saved())
self.rpc.update_owner(owner.key().id(), 'Joe Smith', 'Joe')
self.assertTrue(owner.saved())
self.assertEqual('Joe Smith', owner.name)
self.assertEqual('Joe', owner.nickname)
def test_approve_request_no_admin(self):
'''
Verify that attempting to approve a request as non admin user
raises a PermissionDeniedError
'''
self.assertRaises(PermissionDeniedError, self.rpc.approve_request, 1)
def test_deny_request_no_admin(self):
'''
Verify that attempting to approve a request as non admin user
raises a PermissionDeniedError
'''
self.assertRaises(PermissionDeniedError, self.rpc.approve_request, 1)
def test_approve_request(self):
'''
Confirm approving a request for access to all i want
'''
self.set_user(User(is_admin=True))
user = User(email='*****@*****.**')
req = self.db.add_req(user)
self.assertEqual({}, self.ae.msg)
self.rpc.approve_request(req.key().id())
self.assertEqual(0, len(self.db.request_ids))
owner = self.db.owners.values()[0]
self.assertEqual(user, owner.user)
msg = self.ae.msg
self.assertEqual(self.ae.FROM_ADDRESS, msg['f'])
self.assertEqual(owner.email, msg['t'])
self.assertEqual('Account Activated', msg['s'])
body = self.ae.APPROVE_TEMPLATE % extract_name(owner.email)
self.assertEqual(body, msg['b'])
def test_deny_request(self):
'''
Confirm verifying a request for access to all i want
'''
self.set_user(User(is_admin=True))
user = User(email='*****@*****.**')
req = self.db.add_req(user)
self.assertEqual({}, self.ae.msg)
self.rpc.approve_request(req.key().id())
self.assertEqual(0, len(self.db.request_ids))
owner = self.db.owners.values()[0]
self.assertEqual(user, owner.user)
msg = self.ae.msg
self.assertEqual(self.ae.FROM_ADDRESS, msg['f'])
self.assertEqual(owner.email, msg['t'])
self.assertEqual('Account Activated', msg['s'])
body = self.ae.APPROVE_TEMPLATE % extract_name(owner.email)
self.assertEqual(body, msg['b'])
class ListRpcTest(unittest.TestCase):
def setUp(self):
self.db = MockAccess(User(), add_owner=True)
self.ae = MockWrapper()
self.rpc = ListRpcGroup(self.db, self.ae)
def set_user(self, user):
self.db.user = user
def set_owner(self, owner):
self.db.owner = owner
self.db.user = owner.user
def delete_owner(self):
oid = self.db.owner.key().id()
self.db.delete(self.db.owner)
self.db.owner = None
return oid
def create_group(self, created_by, members, name='Group', desc='Desc'):
g = self.db.add_group(name, desc, created_by)
[ self.db.add_group_member(g, o) for o in members ]
return g
def create_list(self, oid, idx, count):
_ = lambda x: '{} {}'.format(x, idx)
wl = self.db.add_list(oid, _('List'), _('List Desc'))
lid = wl.key().id()
for idx in xrange(count):
self.db.add_list_item(lid, _('Item'), _('Cat'), _('Desc'),
_('url'), idx % 2 == 0)
def create_lists(self, owner, count):
oid = owner.key().id()
for i in xrange(count):
self.create_list(oid, i, 2 * i)
def compare_all_lists(self, lists, wlists):
self.assertEqual(len(lists), len(wlists))
for l, wl in zip(lists, wlists):
self.compare_lists(l, wl)
def compare_lists(self, l, wl):
l_items, wl_items = (l.items, wl.items)
self.assertEqual(len(l_items), len(wl_items))
for item, witem in zip(l_items, wl_items):
self.compare_items(item, witem)
def compare_items(self, item, witem):
ga, eq = (getattr, self.assertEqual)
_ = lambda x: x.label() if x is not None else ''
attrs = ('name', 'category', 'description', 'url', 'is_surprise')
[ eq(ga(item, a), ga(witem, a)) for a in attrs ]
eq(_(item.purchased_by), witem.purchased_by)
eq(_(item.reserved_by), witem.reserved_by)
def test_add_list(self):
'''
Confirm that add_list actually adds a list
'''
oid = self.db.owner.key().id()
self.rpc.add_list(oid, 'List Name', 'List Desc')
self.assertEqual(1, len(self.db.lists))
l = self.db.lists.values()[0]
self.assertTrue(l.key().id() in range(1, 1001))
self.assertEqual('List Name', l.name)
self.assertEqual('List Desc', l.description)
def test_add_list_no_owner(self):
'''
Confirm that trying to add a list with no owner raises a
PermissionDeniedError
'''
oid = self.delete_owner()
with self.assertRaises(PermissionDeniedError):
self.rpc.add_list(oid, 'Name', 'Desc')
def test_add_list_other_owner(self):
'''
Confirm that trying to add a list for another owner raises a
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
oid = o.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.add_list(oid, 'Name', 'Desc')
def test_add_list_duplicate_name(self):
'''
Confirm that trying to add a list with a duplicate name raises
a DuplicateNameError
'''
oid = self.db.owner.key().id()
name = 'My Wish List'
self.db.add_list(oid, name, 'Description')
with self.assertRaises(DuplicateNameError):
self.rpc.add_list(oid, name, 'Another List Description')
def test_update_list(self):
'''
Confirm that update_list actually updates a list
'''
oid = self.db.owner.key().id()
l = self.db.add_list(oid, 'Name', 'Description')
lid = l.key().id()
self.rpc.update_list(lid, 'New Name', 'New Desc')
self.assertEqual(1, len(self.db.lists))
l = self.db.lists.values()[0]
self.assertEqual('New Name', l.name)
self.assertEqual('New Desc', l.description)
def test_update_list_no_owner(self):
'''
Confirm that trying to update a list with no owner raises a
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
l = self.db.add_list(o.key().id(), 'List Name', 'List Desc')
lid = l.key().id()
self.delete_owner()
with self.assertRaises(PermissionDeniedError):
self.rpc.update_list(lid, 'Name', 'Desc')
def test_update_list_invalid_owner(self):
'''
Confirm that trying to add a list for an invalid owner raises a
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
oid = o.key().id()
l = self.db.add_list(oid, 'New List', 'New Desc')
lid = l.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.update_list(lid, 'Name', 'Desc')
def test_update_list_duplicate_name(self):
'''
Confirm that trying to update a list with a duplicate name raises
a DuplicateNameError
'''
oid = self.db.owner.key().id()
name = 'My Wish List'
self.db.add_list(oid, name, 'Description')
l = self.db.add_list(oid, 'Second Name', 'Second Description')
lid = l.key().id()
with self.assertRaises(DuplicateNameError):
self.rpc.update_list(lid, name, 'Another List Description')
def test_get_list_no_owner(self):
'''
Confirm that trying to get lists with no owner raises a
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
oid = o.key().id()
self.delete_owner()
with self.assertRaises(PermissionDeniedError):
self.rpc.get_lists(oid)
def test_get_lists_invalid_owner(self):
'''
Confirm that trying to get lists for an invalid owner raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
oid = o.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.get_lists(oid)
def test_get_own_lists(self):
'''
Confirm that get_lists works for current owner
'''
oid = self.db.owner.key().id()
def _add(i):
return self.db.add_list(oid, 'List {}'.format(i),
'Desc {}'.format(i))
lists = [ _add(i) for i in '12345' ]
wls = self.rpc.get_lists(oid)
self.assertEqual(len(lists), len(wls))
def test_get_lists_from_member_of_my_group(self):
'''
Confirm that get_lists works for an owner who is a member of
a group owned by current owner
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(self.db.owner, [o])
oid = o.key().id()
wls = self.rpc.get_lists(oid)
self.compare_all_lists(o.lists, wls)
def test_get_lists_from_member_of_group_im_in(self):
'''
Confirm that get_lists works for an owner who is a member of
a group current owner is also in
'''
o1 = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o1, 5)
self.create_group(o2, [o1, self.db.owner])
oid = o1.key().id()
wls = self.rpc.get_lists(oid)
self.compare_all_lists(o1.lists, wls)
pass
def test_get_lists_from_owner_of_group_im_in(self):
'''
Confirm that get_lists works for an owner who is the owner of
a group current owner is in
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
oid = o.key().id()
wls = self.rpc.get_lists(oid)
self.compare_all_lists(o.lists, wls)
def test_add_item_to_invalid_owner(self):
'''
Confirm that trying to add an item to the list of an invalid owner
raises PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
lid = o.lists[0].key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.add_item(lid, 'item', 'cat', 'desc', 'url', False)
def test_add_surprise_item_to_invalid_owner(self):
'''
Confirm that trying to add a surprise item to the list of an invalid
owner raises PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
lid = o.lists[0].key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.add_item(lid, 'item', 'cat', 'desc', 'url', True)
def test_add_surprise_item_for_fellow_group_memeber(self):
'''
Confirm ability to add a surprise item to a list you have access to
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
l = o.lists[2]
count = len(l.items)
lid = l.key().id()
w_list = self.rpc.add_item(lid, 'item', 'cat', 'desc', 'url', True)
witem = w_list.items[-1]
self.assertEqual(count + 1, len(o.lists[2].items))
self.assertEqual('item', witem.name)
self.assertEqual('cat', witem.category)
self.assertEqual('desc', witem.description)
self.assertEqual('url', witem.url)
self.assertEqual(True, witem.is_surprise)
self.assertEqual(self.db.owner.nickname, witem.reserved_by)
def test_add_item_to_own_list(self):
'''
Confirm ability to add an item to your own list
'''
self.create_lists(self.db.owner, 1)
l = self.db.owner.lists[0]
count = len(l.items)
lid = l.key().id()
w_list = self.rpc.add_item(lid, 'item', 'cat', 'desc', 'url', False)
witem = w_list.items[0]
self.assertEqual(count + 1, len(self.db.owner.lists[0].items))
self.assertEqual('item', witem.name)
self.assertEqual('cat', witem.category)
self.assertEqual('desc', witem.description)
self.assertEqual('url', witem.url)
self.assertEqual(False, witem.is_surprise)
self.assertEqual('', witem.reserved_by)
self.assertEqual('', witem.purchased_by)
def test_update_item_in_own_list(self):
'''
Confirm ability to update an existing item in your own list
'''
self.create_lists(self.db.owner, 2)
l = self.db.owner.lists[1]
count = len(l.items)
item = l.items[0]
iid = item.key().id()
n, c, d, u = ('New Name', 'New Cat', 'New Desc', 'New URL')
w_list = self.rpc.update_item(iid, n, c, d, u)
witem = w_list.items[0]
self.assertEqual(count, len(self.db.owner.lists[1].items))
self.assertEqual(n, witem.name)
self.assertEqual(c, witem.category)
self.assertEqual(d, witem.description)
self.assertEqual(u, witem.url)
def test_update_item_in_invalid_list(self):
''''
Confirm that trying to update an item in someone else's list
raises PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.update_item(iid, 'item', 'cat', 'desc', 'url')
def test_remove_item_from_own_list(self):
'''
Confirm ability to remove an item from your own list
'''
self.create_lists(self.db.owner, 5)
l = self.db.owner.lists[3]
count = len(l.items)
item = l.items[0]
iid = item.key().id()
self.rpc.remove_item(iid)
self.assertEqual(count - 1, len(self.db.owner.lists[3].items))
self.assertTrue(item not in self.db.owner.lists[3].items)
def test_remove_reserved_item_from_own_list(self):
'''
Confirm ability to remove an item from your own list
which has previously been marked as reserved, and that an
email is sent to the reserver
'''
self.create_lists(self.db.owner, 5)
l = self.db.owner.lists[-1]
count = len(l.items)
item = l.items[0]
iid = item.key().id()
o = self.db.add_owner(User('foo', '*****@*****.**'))
item.reserved_by = o
item.put()
self.rpc.remove_item(iid)
self.assertEqual(count - 1, len(self.db.owner.lists[-1].items))
owner = self.db.owner
subject = 'Wish List Item Deleted'
template_tuple = (
item.reserved_by.nickname,
owner.nickname, owner.email, item.name, l.name, 'Reserved',
owner.nickname, owner.email,
)
body = self.ae.DELETED_ITEM_TEMPLATE % template_tuple
msg = dict(f=self.ae.FROM_ADDRESS, t=o.email, s=subject, b=body)
self.assertEqual(msg, self.ae.msg)
def test_remove_purchased_item_from_own_list(self):
'''
Confirm ability to remove an item from your own list
which has previously been marked as purchased, and that an
email is sent to the purchaser
'''
self.create_lists(self.db.owner, 5)
l = self.db.owner.lists[-1]
count = len(l.items)
item = l.items[0]
iid = item.key().id()
o = self.db.add_owner(User('foo', '*****@*****.**'))
item.purchased_by = o
item.put()
self.rpc.remove_item(iid)
self.assertEqual(count - 1, len(self.db.owner.lists[-1].items))
owner = self.db.owner
subject = 'Wish List Item Deleted'
template_tuple = (
item.purchased_by.nickname,
owner.nickname, owner.email, item.name, l.name, 'Purchased',
owner.nickname, owner.email,
)
body = self.ae.DELETED_ITEM_TEMPLATE % template_tuple
msg = dict(f=self.ae.FROM_ADDRESS, t=o.email, s=subject, b=body)
self.assertEqual(msg, self.ae.msg)
def test_remove_item_from_invalid_list(self):
'''
Confirm that trying to remove an item from someone else's
list raises PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
iid = o.lists[2].items[1].key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.remove_item(iid)
def test_reserve_item(self):
'''
Confirm ability to reserve an item from list you can access
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
self.assertEqual(None, item.reserved_by)
self.assertEqual(None, item.purchased_by)
self.rpc.reserve_item(iid)
self.assertEqual(self.db.owner, item.reserved_by)
self.assertEqual(None, item.purchased_by)
def test_reserve_reserved_item(self):
'''
Confirm trying to reserve a reserved item raises UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.reserved_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.reserve_item(iid)
def test_reserve_puchased_item(self):
'''
Confirm trying to reserve a purchased item raises UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.purchased_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.reserve_item(iid)
def test_unreserve_item(self):
'''
Confirm ability to unreserve and item previously reserved by you
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
item.reserved_by = self.db.owner
item.put()
iid = item.key().id()
self.assertEqual(self.db.owner, item.reserved_by)
self.assertEqual(None, item.purchased_by)
self.rpc.unreserve_item(iid)
self.assertEqual(None, item.reserved_by)
self.assertEqual(None, item.purchased_by)
def test_unreserve_item_not_reserved_by_you(self):
'''
Confirm that trying to unrserve an item reserved by someone else
raises a UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.reserved_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.unreserve_item(iid)
def test_reserve_invalid_item(self):
'''
Confirm trying to reserve an item you don't have access to raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.reserve_item(iid)
def test_unreserve_invalid_item(self):
'''
Confirm trying to unreserve an item you don't have access to raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.unreserve_item(iid)
def test_purchase_item(self):
'''
Confirm ability to purchase an item from list you can access
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
self.assertEqual(None, item.reserved_by)
self.assertEqual(None, item.purchased_by)
self.rpc.purchase_item(iid)
self.assertEqual(None, item.reserved_by)
self.assertEqual(self.db.owner, item.purchased_by)
def test_purchase_reserved_item(self):
'''
Confirm trying to purchase a reserved item raises UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.reserved_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.purchase_item(iid)
def test_purchase_puchased_item(self):
'''
Confirm trying to purchase a purchased item raises UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.purchased_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.purchase_item(iid)
def test_purchase_invalid_item(self):
'''
Confirm trying to purchase an item you don't have access to raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.purchase_item(iid)
def test_unpurchase_invalid_item(self):
'''
Confirm trying to unpurchase an item you don't have access to raises
PermissionDeniedError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
item = o.lists[2].items[1]
iid = item.key().id()
with self.assertRaises(PermissionDeniedError):
self.rpc.unpurchase_item(iid)
def test_unpurchase_item(self):
'''
Confirm ability to unpurchase an item you previously purchased
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
item.purchased_by = self.db.owner
item.put()
iid = item.key().id()
self.assertEqual(None, item.reserved_by)
self.assertEqual(self.db.owner, item.purchased_by)
self.rpc.unpurchase_item(iid)
self.assertEqual(None, item.reserved_by)
self.assertEqual(None, item.purchased_by)
def test_unpurchase_item_purchased_by_someone_else(self):
'''
Confirm trying to unpurchase an item purchased by someone else
raises a UserVisibleError
'''
o = self.db.add_owner(User('foo', '*****@*****.**'))
o2 = self.db.add_owner(User('bar', '*****@*****.**'))
self.create_lists(o, 5)
self.create_group(o, [self.db.owner])
item = o.lists[-1].items[-1]
iid = item.key().id()
item.purchased_by = o2
item.put()
with self.assertRaises(UserVisibleError):
self.rpc.unpurchase_item(iid)
def setUp(self):
self.db = MockAccess(User(), add_owner=True)
self.ae = MockWrapper()
self.rpc = ListRpcGroup(self.db, self.ae)
def set_user(self, user):
self.user = user
self.db = MockAccess(self.user)
self.ae = MockAppEngine()
self.rpc = UserRpcGroup(self.db, self.ae)
class UserRpcTest(unittest.TestCase):
def setUp(self):
self.set_user(User())
def set_user(self, user):
self.user = user
self.db = MockAccess(self.user)
self.ae = MockAppEngine()
self.rpc = UserRpcGroup(self.db, self.ae)
def Xtest_get_user_none(self):
"""
Verify that calling get_current_user without being logged in
provides you with a login url
"""
# Start with no user logged in
self.set_user(None)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify nothing but login url is returned
self.assertEqual(None, user.logout_url)
self.assertEqual(None, user.email)
self.assertEqual(None, user.user_id)
self.assertEqual(None, user.nickname)
login_url = self.ae.create_login_url(url)
self.assertEqual(login_url, user.login_url)
def Xtest_get_user(self):
"""
Verify that calling get_current_user while logged in provides you
with a logout url and your login info
"""
self.set_user(User(is_admin=True))
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
base = get_base_url(url)
goodbye = '{}/#Goodbye:'.format(base)
self.assertEqual(self.ae.create_logout_url(goodbye), user.logout_url)
self.assertEqual(self.user.nickname(), user.nickname)
self.assertEqual(self.user.email(), user.email)
self.assertEqual(None, user.login_url)
# Verify owner was created correctly
owner = self.db.user_owners.get(self.user)
self.assertEqual(num_owners + 1, len(self.db.owners))
self.assertEqual(self.user, owner.user)
self.assertEqual(owner.key().id(), user.owner_id)
self.assertEqual(self.user.nickname(), owner.nickname)
self.assertEqual(self.user.email(), owner.email)
self.assertEqual(extract_name(self.user.email()), owner.name)
def Xtest_get_user_owner_exists(self):
"""
Verify that a duplicate owner is not created when get_current_user
is called
"""
# Make sure owner exists before call
owner = self.db.add_owner(self.user)
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# verify still the same owner after the call
self.assertEqual(num_owners, len(self.db.owners))
self.assertEqual(owner.key().id(), user.owner_id)
self.assertEqual(owner, self.db.user_owners[self.user])
def Xtest_get_user_add_req(self):
"""
Verify that when non-admin user tries to log in, an Access Request is
created for them.
"""
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
base = get_base_url(url)
goodbye = '{}/#Goodbye:'.format(base)
self.assertEqual(self.ae.create_logout_url(goodbye), user.logout_url)
self.assertEqual(self.user.nickname(), user.nickname)
self.assertEqual(self.user.email(), user.email)
self.assertEqual(None, user.login_url)
self.assertEqual(-1, user.owner_id)
self.assertEqual(num_owners, len(self.db.owners))
# Verify access request was created correctly
self.assertEqual(1, len(self.db.request_ids))
req = self.db.requests.values()[0]
self.assertEqual(self.user, req.user)
def Xtest_get_user_req_exists(self):
"""
Verify that the second time get_current_user is called, a second
AccessRequest is not created.
"""
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
# Create the request that already exists
self.db.add_req(self.user)
self.assertEqual(1, len(self.db.request_ids))
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
self.assertEqual(None, user.login_url)
self.assertEqual(-1, user.owner_id)
self.assertEqual(num_owners, len(self.db.owners))
# Verify no additional request was created correctly
self.assertEqual(1, len(self.db.request_ids))
def Xtest_get_owner(self):
"""
Verify ability to lookup owner by id
"""
# Make sure the owner exists
owner = self.db.add_owner(self.user)
oid = owner.key().id()
lo = self.rpc.get_owner(oid)
self.assertEqual(oid, lo.id)
self.assertEqual(owner.email, lo.email)
self.assertEqual(owner.nickname, lo.nickname)
self.assertEqual(owner.name, lo.name)
def test_update_owner(self):
"""
Make sure user can change name and nickname of list owner
"""
# Make sure the owner exists
self.set_user(User('John Doe', 'Johnny'))
self.db.add_owner(self.user)
owner = self.db.add_owner(self.user)
self.assertFalse(owner.saved())
self.rpc.update_owner(owner.key().id(), 'Joe Smith', 'Joe')
self.assertTrue(owner.saved())
self.assertEqual('Joe Smith', owner.name)
self.assertEqual('Joe', owner.nickname)
class GroupRpcTest(unittest.TestCase):
def setUp(self):
self.db = MockAccess(User(), add_owner=True)
self.ae = MockWrapper()
self.rpc = GroupRpcGroup(self.db, self.ae)
def set_user(self, user):
self.db.user = user
def set_owner(self, owner):
self.db.owner = owner
self.db.user = owner.user
def add_groups(self, count, include_invites=False):
for i in xrange(1, count + 1):
g = self.db.add_group('Name {}'.format(i), 'Desc {}'.format(i))
self.assertEqual([], g.invitations)
self.assertEqual([], g.members)
if include_invites:
self.db.add_group_invite(g, 'email_{}@domain.com'.format(i))
def compare_group(self, db, group):
self.assertEqual(db.key().id(), group.id)
self.assertEqual(db.name, group.name)
self.assertEqual(db.description, group.description)
def setup_groups(self):
O = self.db.add_owner
self.a1 = O(User('a1', '*****@*****.**', is_admin=True))
self.a2 = O(User('a2', '*****@*****.**', is_admin=True))
self.u1 = O(User('u1', '*****@*****.**'))
self.u2 = O(User('u2', '*****@*****.**'))
self.u3 = O(User('u3', '*****@*****.**'))
self.g1 = self.db.add_group('g1', 'g1desc', self.a1)
self.g2 = self.db.add_group('g2', 'g1desc', self.a2)
self.db.add_group_member(self.g1, self.a1)
self.db.add_group_member(self.g1, self.u1)
self.db.add_group_member(self.g1, self.u3)
self.db.add_group_member(self.g2, self.a2)
self.db.add_group_member(self.g2, self.u2)
self.db.add_group_member(self.g2, self.u3)
def test_add_group(self):
'''
Confirm that add_group actually adds a group
'''
self.db.user.is_admin = True
self.rpc.add_group('Group Name', 'Group Desc')
self.assertEqual(1, len(self.db.groups))
g = self.db.groups.values()[0]
self.assertTrue(g.key().id() in range(1, 1001))
self.assertEqual('Group Name', g.name)
self.assertEqual('Group Desc', g.description)
def test_add_group_requires_admin(self):
'''
Confirm trying to add group with non admin user raised Exception
'''
with self.assertRaises(UserVisibleError):
self.rpc.add_group('Name', 'Desc')
def test_add_group_duplicate_name(self):
'''
Confirm that trying to add a group with a duplicate name raises
a DuplicateNameError
'''
self.db.user.is_admin = True
self.add_groups(1)
name = self.db.groups.values()[0].name
with self.assertRaises(DuplicateNameError):
self.rpc.add_group(name, 'Group Desc')
def test_get_groups(self):
'''
Confirm group retrieval
'''
self.add_groups(5)
groups = self.rpc.get_groups()
self.assertEqual(5, len(groups))
for g, group in zip(self.db.get_groups(), groups):
self.compare_group(g, group)
def test_update_group(self):
'''
Confirm ability to change group name/desc
'''
self.add_groups(1)
id = self.db.group_ids[0]
self.rpc.update_group(id, 'New Name', 'New Desc')
g = self.db.get_group(id)
self.assertEqual('New Name', g.name)
self.assertEqual('New Desc', g.description)
def test_update_group_duplicate_name(self):
'''
Confirm that trying to update a group with a used name raises a
DuplicateNameError
'''
self.add_groups(2)
id = self.db.group_ids[0]
name = self.db.get_group(self.db.group_ids[1]).name
with self.assertRaises(DuplicateNameError):
self.rpc.update_group(id, name, 'New Desc')
def test_update_group_same_name(self):
'''
Confirm that trying to update a group with its own name and a new
description does NOT raise a DuplicateNameError
'''
self.add_groups(1)
g = self.db.groups.values()[0]
self.rpc.update_group(g.key().id(), g.name, 'New Desc')
def test_invite_member(self):
'''
Confirm ability to invite someone to a group
'''
self.add_groups(1)
id = self.db.group_ids[0]
group = self.db.groups[id]
self.assertEqual(0, len(group.invitations))
self.rpc.invite_member(id, '*****@*****.**')
self.assertEqual(1, len(group.invitations))
invite = group.invitations[0]
self.assertEqual('*****@*****.**', invite.email)
def test_accept_invitation(self):
'''
Confirm ability to accept a group invite
'''
self.add_groups(1, include_invites=True)
invite = self.db.invitations.values()[0]
group = invite.group
num_invites = len(group.invitations)
self.rpc.accept_invitation(invite.key().id())
self.assertEqual(num_invites - 1, len(group.invitations))
self.assertEqual(1, len(group.members))
self.assertEqual(self.db.owner, group.members[0].member)
def test_decline_invitation(self):
'''
Confirm ability to decline a group invitation
'''
self.add_groups(1, include_invites=True)
invite = self.db.invitations.values()[0]
group = invite.group
num_invites = len(group.invitations)
num_members = len(group.members)
self.rpc.decline_invitation(invite.key().id())
self.assertEqual(num_invites - 1, len(group.invitations))
self.assertEqual(num_members, len(group.members))
self.assertTrue(invite not in self.db.invitations.values())
def test_get_available_owners_a1(self):
'''
Confirm lookup of all available users for a1 owner
'''
self.setup_groups()
self.set_owner(self.a1)
owners = self.rpc.get_available_owners(self.a1.key().id())
self.assertEqual(3, len(owners))
expected = set((o.email for o in (self.a1, self.u1, self.u3)))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def test_get_available_owners_a2(self):
'''
Confirm lookup of all available users for a2 owner
'''
self.setup_groups()
self.set_owner(self.a2)
owners = self.rpc.get_available_owners(self.a2.key().id())
self.assertEqual(3, len(owners))
expected = set((o.email for o in (self.a2, self.u2, self.u3)))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def test_get_available_owners_u1(self):
'''
Confirm lookup of all available users for u1 owner
'''
self.setup_groups()
self.set_owner(self.u1)
owners = self.rpc.get_available_owners(self.u1.key().id())
self.assertEqual(3, len(owners))
expected = set((o.email for o in (self.a1, self.u1, self.u3)))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def test_get_available_owners_u2(self):
'''
Confirm lookup of all available users for u2 owner
'''
self.setup_groups()
self.set_owner(self.u2)
owners = self.rpc.get_available_owners(self.u2.key().id())
self.assertEqual(3, len(owners))
expected = set((o.email for o in (self.a2, self.u2, self.u3)))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
def test_get_available_owners_u3(self):
'''
Confirm lookup of all available users for u3 owner
'''
self.setup_groups()
self.set_owner(self.u3)
owners = self.rpc.get_available_owners(self.u3.key().id())
self.assertEqual(5, len(owners))
all = (self.a1, self.a2, self.u1, self.u2, self.u3)
expected = set((o.email for o in all))
actual = set((o.email for o in owners))
self.assertEqual(expected, actual)
class UserRpcTest(unittest.TestCase):
def setUp(self):
self.set_user(User())
def set_user(self, user):
self.user = user
self.db = MockAccess(self.user)
self.ae = MockWrapper()
self.rpc = UserRpcGroup(self.db, self.ae)
def test_get_user_none(self):
'''
Verify that calling get_current_user without being logged in
provides you with a login url
'''
# Start with no user logged in
self.set_user(None)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify nothing but login url is returned
self.assertEqual(None, user.logout_url)
self.assertEqual(None, user.email)
self.assertEqual(None, user.user_id)
self.assertEqual(None, user.nickname)
login_url = self.ae.create_login_url(url)
self.assertEqual(login_url, user.login_url)
def test_get_user(self):
'''
Verify that calling get_current_user while logged in provides you
with a logout url and your login info
'''
self.set_user(User(is_admin=True))
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
base = get_base_url(url)
goodbye = '{}/#Goodbye:'.format(base)
self.assertEqual(self.ae.create_logout_url(goodbye), user.logout_url)
self.assertEqual(self.user.nickname(), user.nickname)
self.assertEqual(self.user.email(), user.email)
self.assertEqual(None, user.login_url)
# Verify owner was created correctly
owner = self.db.user_owners.get(self.user)
self.assertEqual(num_owners + 1, len(self.db.owners))
self.assertEqual(self.user, owner.user)
self.assertEqual(owner.key().id(), user.owner_id)
self.assertEqual(self.user.nickname(), owner.nickname)
self.assertEqual(self.user.email(), owner.email)
self.assertEqual(extract_name(self.user.email()), owner.name)
def test_get_user_owner_exists(self):
'''
Verify that a duplicate owner is not created when get_current_user
is called
'''
# Make sure owner exists before call
owner = self.db.add_owner(self.user)
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# verify still the same owner after the call
self.assertEqual(num_owners, len(self.db.owners))
self.assertEqual(owner.key().id(), user.owner_id)
self.assertEqual(owner, self.db.user_owners[self.user])
def test_get_user_add_req(self):
'''
Verify that when non-admin user tries to log in, an Access Request is
created for them.
'''
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
base = get_base_url(url)
goodbye = '{}/#Goodbye:'.format(base)
self.assertEqual(self.ae.create_logout_url(goodbye), user.logout_url)
self.assertEqual(self.user.nickname(), user.nickname)
self.assertEqual(self.user.email(), user.email)
self.assertEqual(None, user.login_url)
self.assertEqual(-1, user.owner_id)
self.assertEqual(num_owners, len(self.db.owners))
# Verify access request was created correctly
self.assertEqual(1, len(self.db.request_ids))
req = self.db.requests.values()[0]
self.assertEqual(self.user, req.user)
def test_get_user_req_exists(self):
'''
Verify that the second time get_current_user is called, a second
AccessRequest is not created.
'''
# Verify no owner exists before call
self.assertEqual(None, self.db.user_owners.get(self.user, None))
num_owners = len(self.db.owners)
# Create the request that already exists
self.db.add_req(self.user)
self.assertEqual(1, len(self.db.request_ids))
url = 'http://www.domain.com/some/extra/path/'
user = self.rpc.get_current_user(url)
# Verify correct user details are returned
self.assertEqual(None, user.login_url)
self.assertEqual(-1, user.owner_id)
self.assertEqual(num_owners, len(self.db.owners))
# Verify no additional request was created correctly
self.assertEqual(1, len(self.db.request_ids))
def test_get_owner(self):
'''
Verify ability to lookup owner by id
'''
# Make sure the owner exists
owner = self.db.add_owner(self.user)
oid = owner.key().id()
lo = self.rpc.get_owner(oid)
self.assertEqual(oid, lo.id)
self.assertEqual(owner.email, lo.email)
self.assertEqual(owner.nickname, lo.nickname)
self.assertEqual(owner.name, lo.name)
def test_update_owner(self):
'''
Make sure user can change name and nickname of list owner
'''
# Make sure the owner exists
self.set_user(User('John Doe', 'Johnny'))
self.db.add_owner(self.user)
owner = self.db.add_owner(self.user)
self.assertFalse(owner.saved())
self.rpc.update_owner(owner.key().id(), 'Joe Smith', 'Joe')
self.assertTrue(owner.saved())
self.assertEqual('Joe Smith', owner.name)
self.assertEqual('Joe', owner.nickname)
def test_approve_request_no_admin(self):
'''
Verify that attempting to approve a request as non admin user
raises a PermissionDeniedError
'''
self.assertRaises(PermissionDeniedError, self.rpc.approve_request, 1)
def test_deny_request_no_admin(self):
'''
Verify that attempting to approve a request as non admin user
raises a PermissionDeniedError
'''
self.assertRaises(PermissionDeniedError, self.rpc.approve_request, 1)
def test_approve_request(self):
'''
Confirm approving a request for access to all i want
'''
self.set_user(User(is_admin=True))
user = User(email='*****@*****.**')
req = self.db.add_req(user)
self.assertEqual({}, self.ae.msg)
self.rpc.approve_request(req.key().id())
self.assertEqual(0, len(self.db.request_ids))
owner = self.db.owners.values()[0]
self.assertEqual(user, owner.user)
msg = self.ae.msg
self.assertEqual(self.ae.FROM_ADDRESS, msg['f'])
self.assertEqual(owner.email, msg['t'])
self.assertEqual('Account Activated', msg['s'])
body = self.ae.APPROVE_TEMPLATE % extract_name(owner.email)
self.assertEqual(body, msg['b'])
def test_deny_request(self):
'''
Confirm verifying a request for access to all i want
'''
self.set_user(User(is_admin=True))
user = User(email='*****@*****.**')
req = self.db.add_req(user)
self.assertEqual({}, self.ae.msg)
self.rpc.approve_request(req.key().id())
self.assertEqual(0, len(self.db.request_ids))
owner = self.db.owners.values()[0]
self.assertEqual(user, owner.user)
msg = self.ae.msg
self.assertEqual(self.ae.FROM_ADDRESS, msg['f'])
self.assertEqual(owner.email, msg['t'])
self.assertEqual('Account Activated', msg['s'])
body = self.ae.APPROVE_TEMPLATE % extract_name(owner.email)
self.assertEqual(body, msg['b'])
def setUp(self):
self.db = MockAccess(User(), add_owner=True)
self.ae = MockAppEngine()
self.rpc = GroupRpcGroup(self.db, self.ae)