def test_get_tags(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('content', 'doc1', 'caroline', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
tags = g.unpack(g.get_tags('content', 'doc1', 'caroline'))
self.assertEqual(tags, ['leadership', 'negotiations'])
def test_get_bookmarks_by_date(self):
g = NetworkGraph()
g.bookmark('content', 'fake_uuid_1')
g.bookmark('content', 'fake_uuid_2')
bookmarks = g.get_bookmarks_by_date('content')
self.assertEquals(bookmarks[0].id, 'fake_uuid_1')
self.assertTrue(bookmarks[1].datetime >= bookmarks[0].datetime)
def test_unpack_treeset(self):
struct = OOBTree.OOTreeSet()
struct.insert('foo')
struct.insert('bar')
g = NetworkGraph()
flat = g.unpack(struct)
self.assertEqual(flat, ['bar', 'foo'])
def test_unpack_treeset(self):
struct = OOBTree.OOTreeSet()
struct.insert('foo')
struct.insert('bar')
g = NetworkGraph()
flat = g.unpack(struct)
self.assertEqual(flat, ['bar', 'foo'])
def test_user_follow_unfollow(self):
g = NetworkGraph()
g.follow('user', u'bernard ☀')
self.assertTrue(g.is_following('user', u'bernard ☀'))
self.assertIn(u'bernard ☀', g.get_following('user'))
g.unfollow('user', u'bernard ☀')
self.assertFalse(g.is_following('user', u'bernard ☀'))
self.assertNotIn(u'bernard ☀', g.get_following('user'))
def test_unpack_btree_treeset(self):
struct = OOBTree.OOBTree()
struct['foo'] = OOBTree.OOTreeSet()
struct['foo'].insert('baz')
struct['foo'].insert('bar')
g = NetworkGraph()
flat = g.unpack(struct)
self.assertEqual(flat, {'foo': ['bar', 'baz']})
def test_unpack_btree_treeset(self):
struct = OOBTree.OOBTree()
struct['foo'] = OOBTree.OOTreeSet()
struct['foo'].insert('baz')
struct['foo'].insert('bar')
g = NetworkGraph()
flat = g.unpack(struct)
self.assertEqual(flat, {'foo': ['bar', 'baz']})
def test_get_tagged_all(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('user', 'caroline', 'alex', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
tagged = sorted(list(g.get_tagged('user', 'alex', 'leadership')))
self.assertEqual(tagged, ['bernard', 'caroline'])
tagged = sorted(list(g.get_tagged('content', 'alex', 'negotiations')))
self.assertEqual(tagged, ['doc1'])
def test_user_follow_unfollow_followers(self):
g = NetworkGraph()
g.follow('user', 'bernard', 'alex')
g.follow('user', 'bernard', 'caroline')
g.unfollow('user', 'bernard', 'alex')
self.assertEqual(['caroline'],
sorted(list(g.get_followers('user', 'bernard'))))
def test_user_bookmark_unbookmark_content(self):
g = NetworkGraph()
g.bookmark('content', 'fake uuid')
self.assertTrue(g.is_bookmarking('content', 'fake uuid'))
self.assertIn('fake uuid', g.get_bookmarks('content'))
g.unbookmark('content', 'fake uuid')
self.assertFalse(g.is_bookmarking('content', 'fake uuid'))
def test_user_like_unlike(self):
g = NetworkGraph()
g.like('content', 'fake uuid')
self.assertTrue(g.is_liking('content', 'fake uuid'))
self.assertIn('fake uuid', g.get_likes('content'))
g.unlike('content', 'fake uuid')
self.assertFalse(g.is_liking('content', 'fake uuid'))
def test_get_tagged_nouserid(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('user', 'caroline', 'alex', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
tagged = g.get_tagged('user', None, 'leadership')
self.assertEqual(tagged, {'bernard': ['alex'], 'caroline': ['alex']})
def test_get_tags(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('content', 'doc1', 'caroline', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
tags = g.unpack(g.get_tags('content', 'doc1', 'caroline'))
self.assertEqual(tags, ['leadership', 'negotiations'])
def test_user_follow_following(self):
g = NetworkGraph()
g.follow('user', 'bernard', 'alex')
g.follow('user', 'caroline', 'alex')
g.follow('user', 'dick', 'alex')
self.assertEqual(['bernard', 'caroline', 'dick'],
sorted(list(g.get_following('user', 'alex'))))
def test_get_tagged_all(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('user', 'caroline', 'alex', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
tagged = sorted(list(g.get_tagged('user', 'alex', 'leadership')))
self.assertEqual(tagged, ['bernard', 'caroline'])
tagged = sorted(list(g.get_tagged('content', 'alex', 'negotiations')))
self.assertEqual(tagged, ['doc1'])
def test_user_follow_unfollow_followers(self):
g = NetworkGraph()
g.follow('user', 'bernard', 'alex')
g.follow('user', 'bernard', 'caroline')
g.unfollow('user', 'bernard', 'alex')
self.assertEqual(['caroline'],
sorted(list(g.get_followers('user', 'bernard'))))
def test_user_follow_following(self):
g = NetworkGraph()
g.follow('user', 'bernard', 'alex')
g.follow('user', 'caroline', 'alex')
g.follow('user', 'dick', 'alex')
self.assertEqual(['bernard', 'caroline', 'dick'],
sorted(list(g.get_following('user', 'alex'))))
def test_user_is_followed(self):
g = NetworkGraph()
g.follow('user', 'bernard', 'alex')
self.assertTrue(g.is_followed('user', 'bernard', 'alex'))
self.assertFalse(g.is_followed('user', 'alex', 'bernard'))
self.assertFalse(g.is_followed('user', 'caroline', 'alex'))
self.assertFalse(g.is_followed('tag', 'bernard', 'alex'))
def test_get_tagged_nouserid(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('user', 'caroline', 'alex', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
tagged = g.get_tagged('user', None, 'leadership')
self.assertEqual(
tagged, {'bernard': ['alex'], 'caroline': ['alex']}
)
def test_user_is_followed(self):
g = NetworkGraph()
g.follow('user', 'bernard', 'alex')
self.assertTrue(g.is_followed('user', 'bernard', 'alex'))
self.assertFalse(g.is_followed('user', 'alex', 'bernard'))
self.assertFalse(g.is_followed('user', 'caroline', 'alex'))
self.assertFalse(g.is_followed('tag', 'bernard', 'alex'))
def test_is_tagged(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
self.assertTrue(
g.is_tagged('user', 'bernard', 'alex', 'change management'))
self.assertFalse(g.is_tagged('user', 'bernard', 'alex', 'negotiation'))
self.assertFalse(g.is_tagged('content', 'doc1', 'alex', 'leadership'))
def test_utf8_args(self):
"""BTree keys MUST be of type unicode. Check that the implementation
enforces this."""
g = NetworkGraph()
self.assertRaises(AttributeError, g.follow, 'user', 1, '2')
self.assertRaises(AttributeError, g.follow, 'user', '1', 2)
self.assertRaises(AttributeError, g.unfollow, 'user', 1, '2')
self.assertRaises(AttributeError, g.unfollow, 'user', '1', 2)
self.assertRaises(AttributeError, g.get_following, 'user', 2)
self.assertRaises(AttributeError, g.get_followers, 'user', 2)
def test_utf8_args(self):
"""BTree keys MUST be of type unicode. Check that the implementation
enforces this."""
g = NetworkGraph()
self.assertRaises(AttributeError, g.tag, 'user', 1, '2', '3')
self.assertRaises(AttributeError, g.tag, 'user', '1', 2, '3')
self.assertRaises(AttributeError, g.tag, 'user', '1', '2', 3)
self.assertRaises(AttributeError, g.untag, 'user', 1, '2', '3')
self.assertRaises(AttributeError, g.untag, 'user', '1', 2, '3')
self.assertRaises(AttributeError, g.untag, 'user', '1', '2', 3)
def test_utf8_args(self):
"""BTree keys MUST be of type unicode. Check that the implementation
enforces this."""
g = NetworkGraph()
self.assertRaises(AttributeError, g.like, 'content', 1, '2')
self.assertRaises(AttributeError, g.like, 'content', '1', 2)
self.assertRaises(AttributeError, g.unlike, 'content', 1, '2')
self.assertRaises(AttributeError, g.unlike, 'content', '1', 2)
self.assertRaises(AttributeError, g.get_likes, 'content', 1)
self.assertRaises(AttributeError, g.get_likers, 'content', 1)
self.assertRaises(AttributeError, g.is_liked, 'content', 1, 2)
def test_get_tagged_noparams(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('user', 'caroline', 'alex', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
tagged = g.get_tagged()
self.assertEqual(
tagged, {'alex': {'change management': {'content': [],
'user': ['bernard']},
'leadership': {'content': [],
'user': ['bernard', 'caroline']},
'negotiations': {'content': ['doc1'],
'user': ['caroline']}}}
)
def test_is_tagged(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
self.assertTrue(
g.is_tagged('user', 'bernard', 'alex', 'change management'))
self.assertFalse(
g.is_tagged('user', 'bernard', 'alex', 'negotiation'))
self.assertFalse(
g.is_tagged('content', 'doc1', 'alex', 'leadership'))
def test_get_tagged_only_user_id(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('user', 'caroline', 'alex', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
tagged = g.get_tagged(None, 'alex', None)
self.assertEqual(
tagged, {
'change management': {
'content': [],
'user': ['bernard']
},
'leadership': {
'content': [],
'user': ['bernard', 'caroline']
},
'negotiations': {
'content': ['doc1'],
'user': ['caroline']
}
})
def test_to_0003(self):
''' Check that the network graph is fixed by this upgrade
'''
# Remove from ng tool the attributes added in version 0003
ng = NetworkGraph()
delattr(ng, '_bookmarks')
delattr(ng, '_bookmarked')
# the storages for bookmarks are no longer there
# as it was up to version 0002
with self.assertRaises(AttributeError):
ng._bookmarks
ng._bookmarked
with patch('plone.api.portal.get_tool', return_value=ng):
upgrade_to_0003(None)
# the storages for bookmarks are back again
for item_type in ng.supported_bookmark_types:
self.assertTupleEqual(tuple(ng._bookmarks[item_type].keys()), ())
self.assertTupleEqual(tuple(ng._bookmarked[item_type].keys()), ())
def setUp(self):
self.userid = '*****@*****.**'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.statusid = str(long(time.time() * 1e6))
self.container = NetworkGraph()
class TestLikeMixed(unittest.TestCase):
def setUp(self):
self.userid = '*****@*****.**'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.statusid = str(long(time.time() * 1e6))
self.container = NetworkGraph()
def assertIterEqual(self, iterA, iterB):
return self.assertEqual([x for x in iterA], [x for x in iterB])
def test_like_mixed(self):
self.assertIterEqual(self.container.get_likes("content", self.userid),
[])
self.assertIterEqual(self.container.get_likes("update", self.userid),
[])
self.container.like("content", self.object_uuid, self.userid)
self.container.like("update", self.statusid, self.userid)
self.assertIterEqual(self.container.get_likes("content", self.userid),
[self.object_uuid])
self.assertIterEqual(self.container.get_likes("update", self.userid),
[self.statusid])
self.container.unlike("content", self.object_uuid, self.userid)
self.container.unlike("update", self.statusid, self.userid)
self.assertIterEqual(self.container.get_likes("content", self.userid),
[])
self.assertIterEqual(self.container.get_likes("update", self.userid),
[])
def setUp(self):
# self.portal = self.layer['portal']
self.userid = '*****@*****.**'
self.statusid = str(long(time.time() * 1e6))
self.container = NetworkGraph()
class TestLikeUpdate(unittest.TestCase):
def setUp(self):
# self.portal = self.layer['portal']
self.userid = '*****@*****.**'
self.statusid = str(long(time.time() * 1e6))
self.container = NetworkGraph()
def _like_update(self):
self.container.like("update", self.statusid, self.userid)
def test_like_update(self):
self._like_update()
liked_items = self.container.get_likes("update", self.userid)
self.assertEqual(sorted(list(liked_items)), [self.statusid])
liking_users = self.container.get_likers("update", self.statusid)
self.assertEqual(sorted(list(liking_users)), [self.userid])
def test_update_liked_by_two_users(self):
self._like_update()
self.container.like("update", self.statusid, '*****@*****.**')
liked_items = self.container.get_likes("update", self.userid)
self.assertEqual(sorted(list(liked_items)), [self.statusid])
liked_items = self.container.get_likes("update", '*****@*****.**')
self.assertEqual(sorted(list(liked_items)), [self.statusid])
liking_users = self.container.get_likers("update", self.statusid)
self.assertEqual(sorted(list(liking_users)),
['*****@*****.**', self.userid])
def test_unlike_update(self):
self._like_update()
self.container.unlike("update", self.statusid, self.userid)
liked_items = self.container.get_likes("update", self.userid)
self.assertEqual(sorted(list(liked_items)), [])
liking_users = self.container.get_likers("update", self.statusid)
self.assertEqual(sorted(list(liking_users)), [])
def test_get_update_likes(self):
self._like_update()
self.assertEqual(
sorted(list(self.container.get_likes("update", self.userid))),
[self.statusid])
def test_get_update_likes_empty(self):
self.assertEqual(self.container.get_likes("update", self.userid), [])
def test_is_update_liked(self):
self.assertFalse(
self.container.is_liked("update", self.statusid, self.userid))
self._like_update()
self.assertTrue(
self.container.is_liked("update", self.statusid, self.userid))
def test_get_update_likers(self):
self._like_update()
self.assertIn(self.userid,
self.container.get_likers("update", self.statusid))
def test_get_update_likers_empty(self):
self.assertEqual(self.container.get_likers("update", self.statusid),
[])
def test_user_tag_untag(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.untag('user', 'bernard', 'alex', 'leadership')
self.assertEqual(['change management'],
list(g.get_tags('user', 'bernard', 'alex')))
def test_content_follow_unfollow_following(self):
g = NetworkGraph()
g.follow('content', 'doc1', 'alex')
g.follow('content', 'doc2', 'alex')
g.unfollow('content', 'doc1', 'alex')
self.assertEqual(['doc2'], list(g.get_following('content', 'alex')))
class TestLikeContent(unittest.TestCase):
def setUp(self):
# self.portal = self.layer['portal']
self.userid = '*****@*****.**'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.container = NetworkGraph()
def _like_content(self):
self.container.like(
"content",
self.object_uuid,
self.userid,
)
def test_like_content(self):
self._like_content()
liked_items = self.container.get_likes("content", self.userid)
self.assertEqual(sorted(list(liked_items)), [self.object_uuid])
liking_users = self.container.get_likers("content", self.object_uuid)
self.assertEqual(sorted(list(liking_users)), [self.userid])
def test_like_content_utf8(self):
userid = u'M♥rÿ@test.org'
self.container.like(
"content",
self.object_uuid,
userid,
)
liked_items = self.container.get_likes("content", userid)
self.assertEqual(sorted(list(liked_items)), [self.object_uuid])
liking_users = self.container.get_likers("content", self.object_uuid)
self.assertEqual(sorted(list(liking_users)), [userid])
def test_utf8_args(self):
"""BTree keys MUST be of type unicode. Check that the implementation
enforces this."""
g = NetworkGraph()
self.assertRaises(AttributeError, g.like, 'content', 1, '2')
self.assertRaises(AttributeError, g.like, 'content', '1', 2)
self.assertRaises(AttributeError, g.unlike, 'content', 1, '2')
self.assertRaises(AttributeError, g.unlike, 'content', '1', 2)
self.assertRaises(AttributeError, g.get_likes, 'content', 1)
self.assertRaises(AttributeError, g.get_likers, 'content', 1)
self.assertRaises(AttributeError, g.is_liked, 'content', 1, 2)
def test_content_liked_by_two_users(self):
self._like_content()
self.container.like(
"content",
self.object_uuid,
'*****@*****.**',
)
liked_items = self.container.get_likes("content", self.userid)
self.assertEqual(sorted(list(liked_items)), [self.object_uuid])
liked_items = self.container.get_likes("content", '*****@*****.**')
self.assertEqual(sorted(list(liked_items)), [self.object_uuid])
liking_users = self.container.get_likers("content", self.object_uuid)
self.assertEqual(sorted(list(liking_users)),
['*****@*****.**', self.userid])
def test_unlike_content(self):
self._like_content()
self.container.unlike("content", self.object_uuid, self.userid)
liked_items = self.container.get_likes("content", self.userid)
self.assertEqual(sorted(list(liked_items)), [])
liking_users = self.container.get_likers("content", self.object_uuid)
self.assertEqual(sorted(list(liking_users)), [])
def test_get_content_likes(self):
self._like_content()
self.assertEqual(
sorted(list(self.container.get_likes("content", self.userid))),
[self.object_uuid])
def test_get_content_likes_empty(self):
self.assertEqual(self.container.get_likes("content", self.userid), [])
def test_is_content_liked(self):
self.assertFalse(
self.container.is_liked("content", self.object_uuid, self.userid))
self._like_content()
self.assertTrue(
self.container.is_liked("content", self.object_uuid, self.userid))
def test_get_content_likers(self):
self._like_content()
self.assertIn(self.userid,
self.container.get_likers("content", self.object_uuid))
def test_get_content_likers_empty(self):
self.assertEqual(
self.container.get_likers("content", self.object_uuid), [])
def test_content_follow_unfollow_following(self):
g = NetworkGraph()
g.follow('content', 'doc1', 'alex')
g.follow('content', 'doc2', 'alex')
g.unfollow('content', 'doc1', 'alex')
self.assertEqual(['doc2'], list(g.get_following('content', 'alex')))
def test_user_follow_utf8(self):
g = NetworkGraph()
g.follow('user', 'bernard ☀', 'alex ☃') # alex follows bernard
self.assertEqual(
[u'bernard ☀'], list(g.get_following('user', u'alex ☃')))
def test_follow_followers(self):
g = NetworkGraph()
g.set_follow('alex', 'bernard')
g.set_follow('caroline', 'bernard')
self.assertEqual(['alex', 'caroline'],
sorted(list(g.get_followers('bernard'))))
class TestBookmarkContent(unittest.TestCase):
def setUp(self):
self.userid = 'testperson'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.container = NetworkGraph()
def _bookmark_content(self):
self.container.bookmark("content", self.object_uuid, self.userid)
def test_bookmark_content(self):
self._bookmark_content()
items = self.container.get_bookmarks("content", self.userid)
self.assertListEqual(list(items), [self.object_uuid])
users = self.container.get_bookmarkers("content", self.object_uuid)
self.assertListEqual(sorted(list(users)), [self.userid])
def test_bookmark_content_utf8(self):
userid = u'M♥rÿ@test.org'
self.container.bookmark(
"content",
self.object_uuid,
userid,
)
items = self.container.get_bookmarks("content", userid)
self.assertListEqual(sorted(list(items)), [self.object_uuid])
users = self.container.get_bookmarkers("content", self.object_uuid)
self.assertListEqual(sorted(list(users)), [userid])
def test_utf8_args(self):
"""BTree keys MUST be of type unicode. Check that the implementation
enforces this."""
g = NetworkGraph()
with self.assertRaises(AttributeError):
g.bookmark('content', 1, '2')
with self.assertRaises(AttributeError):
g.bookmark('content', '1', 2)
with self.assertRaises(AttributeError):
g.unbookmark('content', 1, '2')
with self.assertRaises(AttributeError):
g.unbookmark('content', '1', 2)
with self.assertRaises(AttributeError):
g.get_bookmarks('content', 1)
with self.assertRaises(AttributeError):
g.get_bookmarkers('content', 1)
with self.assertRaises(AttributeError):
g.is_bookmarked('content', 1, 2)
def test_content_bookmarked_by_two_users(self):
self._bookmark_content()
self.container.bookmark("content", self.object_uuid, '*****@*****.**')
items = self.container.get_bookmarks("content", self.userid)
self.assertListEqual(sorted(list(items)), [self.object_uuid])
items = self.container.get_bookmarks("content", '*****@*****.**')
self.assertListEqual(sorted(list(items)), [self.object_uuid])
users = self.container.get_bookmarkers("content", self.object_uuid)
self.assertListEqual(sorted(list(users)),
['*****@*****.**', self.userid])
def test_unbookmark_content(self):
self._bookmark_content()
self.container.unbookmark("content", self.object_uuid, self.userid)
items = self.container.get_bookmarks("content", self.userid)
self.assertListEqual(sorted(list(items)), [])
users = self.container.get_bookmarkers("content", self.object_uuid)
self.assertListEqual(sorted(list(users)), [])
def test_get_content_bookmarks(self):
self._bookmark_content()
self.assertEqual(
sorted(list(self.container.get_bookmarks("content", self.userid))),
[self.object_uuid])
def test_get_content_bookmarks_empty(self):
self.assertListEqual(
self.container.get_bookmarks("content", self.userid), [])
def test_is_content_bookmarked(self):
self.assertFalse(
self.container.is_bookmarked("content", self.object_uuid,
self.userid))
self._bookmark_content()
self.assertTrue(
self.container.is_bookmarked("content", self.object_uuid,
self.userid))
def test_get_content_bookmarkers(self):
self._bookmark_content()
self.assertIn(
self.userid,
self.container.get_bookmarkers("content", self.object_uuid))
def test_get_content_bookmarkers_empty(self):
self.assertEqual(
self.container.get_bookmarkers("content", self.object_uuid), [])
def setUp(self):
self.userid = 'testperson'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.container = NetworkGraph()
def test_follow_unfollow_following(self):
g = NetworkGraph()
g.set_follow('alex', 'bernard')
g.set_follow('alex', 'caroline')
g.set_unfollow('alex', 'bernard')
self.assertEqual(['caroline'], list(g.get_following('alex')))
def test_tag_follow_unfollow_following(self):
g = NetworkGraph()
g.follow('tag', 'foo', 'alex')
g.follow('tag', 'bar', 'alex')
g.unfollow('tag', 'foo', 'alex')
self.assertEqual(['bar'], list(g.get_following('tag', 'alex')))
class TestLikeMixed(unittest.TestCase):
def setUp(self):
self.userid = '*****@*****.**'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.statusid = str(long(time.time() * 1e6))
self.container = NetworkGraph()
def assertIterEqual(self, iterA, iterB):
return self.assertEqual([x for x in iterA],
[x for x in iterB])
def test_like_mixed(self):
self.assertIterEqual(self.container.get_likes(
"content", self.userid), [])
self.assertIterEqual(self.container.get_likes(
"update", self.userid), [])
self.container.like("content", self.object_uuid, self.userid)
self.container.like("update", self.statusid, self.userid)
self.assertIterEqual(self.container.get_likes(
"content", self.userid), [self.object_uuid])
self.assertIterEqual(self.container.get_likes(
"update", self.userid), [self.statusid])
self.container.unlike("content", self.object_uuid, self.userid)
self.container.unlike("update", self.statusid, self.userid)
self.assertIterEqual(self.container.get_likes(
"content", self.userid), [])
self.assertIterEqual(self.container.get_likes(
"update", self.userid), [])
def setUp(self):
self.userid = '*****@*****.**'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.statusid = str(long(time.time() * 1e6))
self.container = NetworkGraph()
def setUp(self):
# self.portal = self.layer['portal']
self.userid = '*****@*****.**'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.container = NetworkGraph()
def setUp(self):
# self.portal = self.layer['portal']
self.userid = '*****@*****.**'
self.statusid = str(long(time.time() * 1e6))
self.container = NetworkGraph()
def test_tag_follow_unfollow_following(self):
g = NetworkGraph()
g.follow('tag', 'foo', 'alex')
g.follow('tag', 'bar', 'alex')
g.unfollow('tag', 'foo', 'alex')
self.assertEqual(['bar'], list(g.get_following('tag', 'alex')))
def test_user_tag_utf8(self):
g = NetworkGraph()
# alex tags bernard with 'leadership'
g.tag('user', u'bernard ♥', u'alex ☀', u'leadership ☃')
self.assertEqual([u'leadership ☃'],
list(g.get_tags('user', u'bernard ♥', u'alex ☀')))
def test_get_taggers_notag(self):
g = NetworkGraph()
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
g.tag('user', 'caroline', 'alex', 'leadership', 'negotiations')
g.tag('content', 'doc1', 'alex', 'negotiations')
# an extra tag here
g.tag('user', 'bernard', 'caroline', 'negotiations')
taggers = g.unpack(g.get_taggers('user', 'bernard'))
self.assertEqual(taggers,
{'change management': ['alex'],
'leadership': ['alex'],
'negotiations': ['caroline']})
class TestLikeUpdate(unittest.TestCase):
def setUp(self):
# self.portal = self.layer['portal']
self.userid = '*****@*****.**'
self.statusid = str(long(time.time() * 1e6))
self.container = NetworkGraph()
def _like_update(self):
self.container.like("update", self.statusid, self.userid)
def test_like_update(self):
self._like_update()
liked_items = self.container.get_likes("update", self.userid)
self.assertEqual(sorted(list(liked_items)), [self.statusid])
liking_users = self.container.get_likers("update", self.statusid)
self.assertEqual(sorted(list(liking_users)), [self.userid])
def test_update_liked_by_two_users(self):
self._like_update()
self.container.like("update", self.statusid, '*****@*****.**')
liked_items = self.container.get_likes("update", self.userid)
self.assertEqual(sorted(list(liked_items)), [self.statusid])
liked_items = self.container.get_likes("update", '*****@*****.**')
self.assertEqual(sorted(list(liked_items)), [self.statusid])
liking_users = self.container.get_likers("update", self.statusid)
self.assertEqual(
sorted(list(liking_users)),
['*****@*****.**', self.userid])
def test_unlike_update(self):
self._like_update()
self.container.unlike("update", self.statusid, self.userid)
liked_items = self.container.get_likes("update", self.userid)
self.assertEqual(sorted(list(liked_items)), [])
liking_users = self.container.get_likers("update", self.statusid)
self.assertEqual(sorted(list(liking_users)), [])
def test_get_update_likes(self):
self._like_update()
self.assertEqual(
sorted(list(self.container.get_likes("update", self.userid))),
[self.statusid])
def test_get_update_likes_empty(self):
self.assertEqual(self.container.get_likes("update", self.userid), [])
def test_is_update_liked(self):
self.assertFalse(
self.container.is_liked("update", self.statusid, self.userid))
self._like_update()
self.assertTrue(
self.container.is_liked("update", self.statusid, self.userid))
def test_get_update_likers(self):
self._like_update()
self.assertIn(
self.userid,
self.container.get_likers("update", self.statusid)
)
def test_get_update_likers_empty(self):
self.assertEqual(
self.container.get_likers("update", self.statusid), []
)
class TestLikeContent(unittest.TestCase):
def setUp(self):
# self.portal = self.layer['portal']
self.userid = '*****@*****.**'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.container = NetworkGraph()
def _like_content(self):
self.container.like("content", self.object_uuid, self.userid, )
def test_like_content(self):
self._like_content()
liked_items = self.container.get_likes("content", self.userid)
self.assertEqual(sorted(list(liked_items)), [self.object_uuid])
liking_users = self.container.get_likers("content", self.object_uuid)
self.assertEqual(sorted(list(liking_users)), [self.userid])
def test_like_content_utf8(self):
userid = u'M♥rÿ@test.org'
self.container.like("content", self.object_uuid, userid, )
liked_items = self.container.get_likes("content", userid)
self.assertEqual(sorted(list(liked_items)), [self.object_uuid])
liking_users = self.container.get_likers("content", self.object_uuid)
self.assertEqual(sorted(list(liking_users)), [userid])
def test_utf8_args(self):
"""BTree keys MUST be of type unicode. Check that the implementation
enforces this."""
g = NetworkGraph()
self.assertRaises(AttributeError, g.like, 'content', 1, '2')
self.assertRaises(AttributeError, g.like, 'content', '1', 2)
self.assertRaises(AttributeError, g.unlike, 'content', 1, '2')
self.assertRaises(AttributeError, g.unlike, 'content', '1', 2)
self.assertRaises(AttributeError, g.get_likes, 'content', 1)
self.assertRaises(AttributeError, g.get_likers, 'content', 1)
self.assertRaises(AttributeError, g.is_liked, 'content', 1, 2)
def test_content_liked_by_two_users(self):
self._like_content()
self.container.like("content", self.object_uuid, '*****@*****.**', )
liked_items = self.container.get_likes("content", self.userid)
self.assertEqual(sorted(list(liked_items)), [self.object_uuid])
liked_items = self.container.get_likes("content", '*****@*****.**')
self.assertEqual(sorted(list(liked_items)), [self.object_uuid])
liking_users = self.container.get_likers("content", self.object_uuid)
self.assertEqual(
sorted(list(liking_users)),
['*****@*****.**', self.userid])
def test_unlike_content(self):
self._like_content()
self.container.unlike("content", self.object_uuid, self.userid)
liked_items = self.container.get_likes("content", self.userid)
self.assertEqual(sorted(list(liked_items)), [])
liking_users = self.container.get_likers("content", self.object_uuid)
self.assertEqual(sorted(list(liking_users)), [])
def test_get_content_likes(self):
self._like_content()
self.assertEqual(
sorted(list(self.container.get_likes("content", self.userid))),
[self.object_uuid])
def test_get_content_likes_empty(self):
self.assertEqual(self.container.get_likes("content", self.userid), [])
def test_is_content_liked(self):
self.assertFalse(
self.container.is_liked("content", self.object_uuid, self.userid))
self._like_content()
self.assertTrue(
self.container.is_liked("content", self.object_uuid, self.userid))
def test_get_content_likers(self):
self._like_content()
self.assertIn(
self.userid,
self.container.get_likers("content", self.object_uuid)
)
def test_get_content_likers_empty(self):
self.assertEqual(
self.container.get_likers("content", self.object_uuid), []
)
def test_user_follow(self):
g = NetworkGraph()
g.follow('user', 'bernard', 'alex') # alex follows bernard
self.assertEqual(['bernard'], list(g.get_following('user', 'alex')))
def test_user_tag(self):
g = NetworkGraph()
# alex tags bernard with 'leadership'
g.tag('user', 'bernard', 'alex', 'leadership')
self.assertEqual(['leadership'],
list(g.get_tags('user', 'bernard', 'alex')))
def setUp(self):
# self.portal = self.layer['portal']
self.userid = '*****@*****.**'
self.object_uuid = '827e65bd826a89790eba679e0c9ff864'
self.container = NetworkGraph()
def test_user_tag_multi(self):
g = NetworkGraph()
# alex tags bernard with 'leadership' and 'change management'
g.tag('user', 'bernard', 'alex', 'leadership', 'change management')
self.assertEqual(['change management', 'leadership'],
sorted(list(g.get_tags('user', 'bernard', 'alex'))))
def test_user_follow(self):
g = NetworkGraph()
g.follow('user', 'bernard', 'alex') # alex follows bernard
self.assertEqual(['bernard'], list(g.get_following('user', 'alex')))
def test_user_follow_utf8(self):
g = NetworkGraph()
g.follow('user', 'bernard ☀', 'alex ☃') # alex follows bernard
self.assertEqual([u'bernard ☀'],
list(g.get_following('user', u'alex ☃')))
def test_follow(self):
g = NetworkGraph()
g.set_follow('alex', 'bernard')
self.assertEqual(['bernard'], list(g.get_following('alex')))
