def test_load_microblogging_from_user(self):
hugo = create_user("hugo")
herbert = create_user("herbert")
posts = [
create_post("@hugo ", herbert, location=''),
create_post("@herbert @hugo", herbert, location='')
]
wrong_posts = [
create_post("no mentions", hugo, location=''),
create_post("@herbert", hugo, location='')
]
response = self.client.get(
reverse('load_microblogging_from_user', kwargs={'name':
'herbert'}))
res = json.loads(response.content)["loadMicrobloggingResponse"]
response_id_list = [m["microblogID"] for m in res]
for post in posts:
self.assertIn(post.id, response_id_list)
for post in wrong_posts:
self.assertNotIn(post.id, response_id_list)
self.assertEqual(len(res), 2)
def test_delete_posts_referring_to_removes_referring_posts1(self):
hugo = create_user('hugo')
node = create_nodes_for_path("path.1")
create_post("foo", hugo, '/path.1')
self.assertEqual(Post.objects.count(), 1)
delete_posts_referring_to(node)
self.assertEqual(Post.objects.count(), 0)
def setUp(self):
self.root = get_root_node()
self.hugo = create_user("Hugo", password="******", groups=['voters'])
self.slot = create_slot("Slot")
self.root.append_child(self.slot)
self.text = create_textNode("Bla",
"Dieser Text enthält verschiedene Suchbegriffe wie Giraffe, Huhn, Motorrad und Tisch.", [self.hugo])
self.slot.append_child(self.text)
self.post1 = create_post("Ich finde /Slot.1 Huhn.", self.hugo)
self.post1 = create_post("Giraffe Huhn.", self.hugo)
def test_microblogging_response_limited_to_newer_sorted(self):
hugo = create_user("hugo")
for i in range(25):
create_post("text%d" % i, hugo)
response = microblogging_response(Q(), {"type": "newer", "id": 3})
self.assertTrue(validate_response(response.content,
"load_microblogging"))
result = json.loads(response.content)["loadMicrobloggingResponse"]
self.assertEqual(len(result), 20)
self.assertEqual([p['microblogID'] for p in result], range(23, 3, -1))
def setUp(self):
self.root = get_root_node()
self.hugo = create_user("Hugo", password="******", groups=['voters'])
self.slot = create_slot("Slot")
self.root.append_child(self.slot)
self.text = create_textNode(
"Bla",
"Dieser Text enthält verschiedene Suchbegriffe wie Giraffe, Huhn, Motorrad und Tisch.",
[self.hugo])
self.slot.append_child(self.text)
self.post1 = create_post("Ich finde /Slot.1 Huhn.", self.hugo)
self.post1 = create_post("Giraffe Huhn.", self.hugo)
def test_load_microblogging_all_loads_all_microblogging(self):
hugo = create_user("hugo")
herbert = create_user("herbert")
create_nodes_for_path("foo.1")
posts = [create_post("text", hugo, location=''),
create_post("text3", hugo, location='foo.1'),
create_post("text2", herbert, location='foo.1')]
response = self.client.get(reverse('load_microblogging_all'))
res = json.loads(response.content)["loadMicrobloggingResponse"]
ids = [m["microblogID"] for m in res]
for p in posts:
self.assertIn(p.id, ids)
self.assertEqual(len(res), 3)
def test_load_microblogging_all_loads_all_microblogging(self):
hugo = create_user("hugo")
herbert = create_user("herbert")
create_nodes_for_path("foo.1")
posts = [
create_post("text", hugo, location=''),
create_post("text3", hugo, location='foo.1'),
create_post("text2", herbert, location='foo.1')
]
response = self.client.get(reverse('load_microblogging_all'))
res = json.loads(response.content)["loadMicrobloggingResponse"]
ids = [m["microblogID"] for m in res]
for p in posts:
self.assertIn(p.id, ids)
self.assertEqual(len(res), 3)
def test_mail_notify_new_argument(self):
hugo = create_user("hugo")
hugo.email = "*****@*****.**"
hugo.profile.wants_mail_notification = True
hugo.save()
max = create_user("max")
max.email = "*****@*****.**"
max.profile.wants_mail_notification = True
max.save()
berta = create_user("berta")
berta.email = "*****@*****.**"
berta.profile.wants_mail_notification = False
berta.save()
post = create_post('System Message', hugo)
node = create_nodes_for_path('/foo.1', [hugo])
create_vote(hugo, [node])
create_vote(max, [node])
create_vote(berta, [node])
create_argument(node, 'n', 'Bla', 'Blubb', [hugo])
notify_new_argument(node, post)
self.assertEqual(len(mail.outbox), 1)
m = mail.outbox[0]
self.assertEqual(m.to, [])
self.assertEqual(m.bcc, ['*****@*****.**', '*****@*****.**'])
self.assertIn('System Message', m.body)
self.assertGreater(len(m.subject), 0)
def test_load_microblogging_for_node(self):
hugo = create_user("hugo")
create_nodes_for_path("foo.1")
wrong_post = create_post("text", hugo, location='')
posts = [create_post("is only posted there", hugo,
location='foo.1'),
create_post("references /foo.1 and is posted there", hugo,
location='foo.1'),
create_post("references /foo.1 but is not posted there", hugo,
location='')]
response = self.client.get(reverse('load_microblogging_for_node',
kwargs={'path': 'foo.1'}))
res = json.loads(response.content)["loadMicrobloggingResponse"]
self.assertNotIn(wrong_post.id, [m["microblogID"] for m in res])
for post in posts:
self.assertIn(post.id, [m["microblogID"] for m in res])
self.assertEqual(len(res), 3)
def test_mail_notify_send_derivate(self):
hugo = create_user("hugo")
post = create_post('my test posttext', hugo)
send_derivate_notification(post, ['*****@*****.**', '*****@*****.**'])
self.assertEqual(len(mail.outbox), 1)
m = mail.outbox[0]
self.assertEqual(m.to, [])
self.assertEqual(m.bcc, ['*****@*****.**', '*****@*****.**'])
self.assertIn('my test posttext', m.body)
self.assertGreater(len(m.subject), 0)
def test_send_notification_to_sends_mail_via_bcc(self):
hugo = create_user("hugo")
post = create_post('my test posttext', hugo)
send_notification_to('Mail für hugo!', post, ['*****@*****.**', '*****@*****.**'])
self.assertEqual(len(mail.outbox), 1)
m = mail.outbox[0]
self.assertEqual(m.to, [])
self.assertEqual(m.bcc, ['*****@*****.**', '*****@*****.**'])
self.assertIn('my test posttext', m.body)
self.assertIn('hugo', m.subject)
def test_load_microblogging_timeline(self):
hugo = create_user("hugo")
herbert = create_user("herbert")
heinrich = create_user("heinrich")
herbert.profile.followers.add(hugo.profile)
posts = [create_post("Own Post", hugo, location=''),
create_post("Followed Post", herbert, location='')]
wrong_post = create_post("Wrong Post", heinrich, location='')
response = self.client.get(reverse('load_microblogging_timeline',
kwargs={'name': 'hugo'}))
res = json.loads(response.content)["loadMicrobloggingResponse"]
response_id_list = [m["microblogID"] for m in res]
for post in posts:
self.assertIn(post.id, response_id_list)
self.assertNotIn(wrong_post.id, response_id_list)
self.assertEqual(len(res), 2)
def test_load_microblogging_from_user(self):
hugo = create_user("hugo")
herbert = create_user("herbert")
posts = [create_post("@hugo ", herbert, location=''),
create_post("@herbert @hugo", herbert, location='')]
wrong_posts = [
create_post("no mentions", hugo, location=''),
create_post("@herbert", hugo, location='')]
response = self.client.get(reverse('load_microblogging_from_user',
kwargs={'name': 'herbert'}))
res = json.loads(response.content)["loadMicrobloggingResponse"]
response_id_list = [m["microblogID"] for m in res]
for post in posts:
self.assertIn(post.id, response_id_list)
for post in wrong_posts:
self.assertNotIn(post.id, response_id_list)
self.assertEqual(len(res), 2)
def test_change_microblogging_authorship_updates_template_text(self):
hugo = create_user('hugo')
create_user('herbert')
arno = create_user('arno')
post = create_post('hallo @hugo ich bins @herbert!', hugo)
post.save()
self.assertEqual(post.text_template, 'hallo {u0} ich bins {u1}!')
change_microblogging_authorship(hugo, arno)
post = Post.objects.get(id=post.id) # update object from DB
self.assertEqual(post.text_template, 'hallo {u1} ich bins {u0}!')
def test_load_microblogging_for_node(self):
hugo = create_user("hugo")
create_nodes_for_path("foo.1")
wrong_post = create_post("text", hugo, location='')
posts = [
create_post("is only posted there", hugo, location='foo.1'),
create_post("references /foo.1 and is posted there",
hugo,
location='foo.1'),
create_post("references /foo.1 but is not posted there",
hugo,
location='')
]
response = self.client.get(
reverse('load_microblogging_for_node', kwargs={'path': 'foo.1'}))
res = json.loads(response.content)["loadMicrobloggingResponse"]
self.assertNotIn(wrong_post.id, [m["microblogID"] for m in res])
for post in posts:
self.assertIn(post.id, [m["microblogID"] for m in res])
self.assertEqual(len(res), 3)
def test_load_microblogging_for_authored_nodes(self):
hugo = create_user('hugo')
herbert = create_user('herbert')
create_nodes_for_path("foo.1", authors=[herbert])
create_nodes_for_path("foo.2", authors=[hugo])
create_nodes_for_path("foo.1/bar.1", authors=[hugo, herbert])
posts = [create_post("posted at node", hugo, location='foo.2'),
create_post("reference /foo.2", hugo, location=''),
create_post("reference /foo.1/bar.1", hugo, location='foo.2')]
wrong_posts = [create_post("posted somewhere", hugo, location='foo.1'),
create_post("reference wrong /foo.1", hugo, location=''),
create_post("neither", hugo, location='')]
response = self.client.get(
reverse('load_microblogging_for_authored_nodes',
kwargs={'name': 'hugo'}))
res = json.loads(response.content)["loadMicrobloggingResponse"]
response_id_list = [m["microblogID"] for m in res]
for post in posts:
self.assertIn(post.id, response_id_list)
for post in wrong_posts:
self.assertNotIn(post.id, response_id_list)
self.assertEqual(len(res), 3)
def test_load_microblogging_for_authored_nodes(self):
hugo = create_user('hugo')
herbert = create_user('herbert')
create_nodes_for_path("foo.1", authors=[herbert])
create_nodes_for_path("foo.2", authors=[hugo])
create_nodes_for_path("foo.1/bar.1", authors=[hugo, herbert])
posts = [
create_post("posted at node", hugo, location='foo.2'),
create_post("reference /foo.2", hugo, location=''),
create_post("reference /foo.1/bar.1", hugo, location='foo.2')
]
wrong_posts = [
create_post("posted somewhere", hugo, location='foo.1'),
create_post("reference wrong /foo.1", hugo, location=''),
create_post("neither", hugo, location='')
]
response = self.client.get(
reverse('load_microblogging_for_authored_nodes',
kwargs={'name': 'hugo'}))
res = json.loads(response.content)["loadMicrobloggingResponse"]
response_id_list = [m["microblogID"] for m in res]
for post in posts:
self.assertIn(post.id, response_id_list)
for post in wrong_posts:
self.assertNotIn(post.id, response_id_list)
self.assertEqual(len(res), 3)
def setUp(self):
self.horst = create_user('horst')
self.udo = create_user('udo')
self.root = get_root_node()
self.slot1 = create_slot('soon_empty')
self.root.append_child(self.slot1)
self.node = create_structureNode('To be or not to be', 'never both')
self.slot1.append_child(self.node)
self.arg = create_argument(self.node, 'c', "no", "lyrics")
self.path = 'soon_empty.1'
self.child_slot = create_slot('or_to_pee')
self.node.append_child(self.child_slot)
self.child = create_structureNode('or to pee')
self.child_slot.append_child(self.child)
TextCache.objects.create(path=self.path, paragraphs="doesn't matter")
IndexCache.objects.create(path=self.path, index_nodes="doesn't matter")
self.slot2 = create_slot('verfassungswiedrig')
self.root.append_child(self.slot2)
self.source = create_structureNode('BöserTitel', 'gewöhnlicher text')
self.slot2.append_child(self.source)
self.derivate = create_structureNode('BöserTitel',
'verfassungswiedriger text')
self.slot2.append_child(self.derivate)
self.source.add_derivate(self.derivate, arg_type='con',
title="zuSchwach", text="muss fieser werden",
authors=[self.udo])
self.source_path = 'verfassungswiedrig.1'
self.derivate_path = 'verfassungswiedrig.2'
create_vote(self.udo, [self.node])
create_vote(self.horst, [self.source, self.node])
create_spam_flag(self.horst, [self.node])
create_post('i reference /verfassungswiedrig.1 because i like it ',
self.horst, self.path)
def test_load_microblogging_timeline(self):
hugo = create_user("hugo")
herbert = create_user("herbert")
heinrich = create_user("heinrich")
herbert.profile.followers.add(hugo.profile)
posts = [
create_post("Own Post", hugo, location=''),
create_post("Followed Post", herbert, location='')
]
wrong_post = create_post("Wrong Post", heinrich, location='')
response = self.client.get(
reverse('load_microblogging_timeline', kwargs={'name': 'hugo'}))
res = json.loads(response.content)["loadMicrobloggingResponse"]
response_id_list = [m["microblogID"] for m in res]
for post in posts:
self.assertIn(post.id, response_id_list)
self.assertNotIn(wrong_post.id, response_id_list)
self.assertEqual(len(res), 2)
def test_change_microblogging_authorship_updates_mentions(self):
hugo = create_user('hugo')
create_user('herbert')
arno = create_user('arno')
post = create_post('hallo @hugo ich bins @herbert!', hugo)
post.save()
change_microblogging_authorship(hugo, arno)
post = Post.objects.get(id=post.id) # update object from DB
self.assertNotIn(hugo, post.mentions.all())
self.assertIn(arno, post.mentions.all())
def test_change_microblogging_authorship_can_deal_with_duplications(self):
hugo = create_user('hugo')
herbert = create_user('herbert')
post = create_post('hallo @hugo ich bins @herbert!', hugo)
post.save()
self.assertEqual(post.text_template, 'hallo {u0} ich bins {u1}!')
change_microblogging_authorship(hugo, herbert)
post = Post.objects.get(id=post.id) # update object from DB
self.assertNotIn(hugo, post.mentions.all())
self.assertIn(herbert, post.mentions.all())
self.assertEqual(post.text_template, 'hallo {u0} ich bins {u0}!')
def test_mail_notify_mentions(self):
hugo = create_user("hugo")
hugo.email = "*****@*****.**"
hugo.profile.wants_mail_notification = True
hugo.save()
max = create_user("max")
max.email = "*****@*****.**"
max.profile.wants_mail_notification = True
max.save()
berta = create_user("berta")
berta.email = "*****@*****.**"
berta.profile.wants_mail_notification = False
berta.save()
post = create_post('Hallo @max und @berta', hugo)
notify_users(post)
self.assertEqual(len(mail.outbox), 1)
m = mail.outbox[0]
self.assertEqual(m.to, [])
self.assertEqual(m.bcc, ['*****@*****.**'])
self.assertIn('Hallo', m.body)
self.assertIn('max', m.body)
self.assertIn('hugo', m.subject)
