def setUp(self): self.root = get_root_node() self.hugo = create_user("Hugo", password="******", groups=['voters']) self.ulf = create_user("Ulf", password="******", groups=['voters']) self.permela = create_user("Permela", password="******") self.slot = create_slot("Slot") self.root.append_child(self.slot) self.text = create_textNode("Bla", "Blubb", [self.hugo]) self.slot.append_child(self.text) self.mid = create_textNode("Bla derivate", "Blubb2", [self.hugo]) self.slot.append_child(self.mid) self.text.add_derivate(self.mid, arg_type='c', title="dagegen") self.leaf1 = create_textNode("Bla leaf 1", "Blubb3", [self.hugo]) self.slot.append_child(self.leaf1) self.mid.add_derivate(self.leaf1, arg_type='c', title="dagegen2") self.mid2 = create_textNode("Bla derivate 2", "Blubb4", [self.hugo]) self.slot.append_child(self.mid2) self.mid.add_derivate(self.mid2, arg_type='c', title="dagegen") self.leaf2 = create_textNode("Bla leaf 2", "Blubb5", [self.hugo]) self.slot.append_child(self.leaf2) self.mid2.add_derivate(self.leaf2, arg_type='c', title="dagegen") self.follow = create_vote( self.hugo, [self.text, self.mid, self.leaf1, self.mid2, self.leaf2]) self.arg1 = create_argument(self.text, "con", "Wrong!", "Bad!", [self.hugo])
def setUp(self): self.hans = create_user('hans') self.hugo = create_user('hugo') self.root = get_root_node() self.slot1 = create_slot('Wahlprogramm') self.root.append_child(self.slot1) self.structureNode1 = create_structureNode('LangerWahlprogrammTitel', authors=[self.hans]) self.slot1.append_child(self.structureNode1) self.slot11 = create_slot('Transparenz') self.structureNode1.append_child(self.slot11) self.textnode11 = create_textNode('Traaaansparenz', authors=[self.hans]) self.slot11.append_child(self.textnode11) self.slot12 = create_slot('Bildung') self.structureNode1.append_child(self.slot12) self.textnode12 = create_textNode('Biiildung', authors=[self.hans]) self.slot12.append_child(self.textnode12) self.slot13 = create_slot('Datenschutz') self.structureNode1.append_child(self.slot13) self.textnode13 = create_textNode('Daaatenschutz', authors=[self.hans]) self.slot13.append_child(self.textnode13) self.arguments = [] for i in range(1, 25): arg = create_argument(self.textnode11, 'p', "Argument" + str(i), "Text of argument no. " + str(i), [self.hugo, self.hans]) create_vote(self.hugo, [arg]) if i % 2 == 1: create_vote(self.hans, [arg]) create_spam_flag(self.hugo, [arg]) self.arguments.append(arg)
def setUp(self): self.root = get_root_node() self.hugo = create_user("Hugo", password="******", groups=['voters']) self.ulf = create_user("Ulf", password="******", groups=['voters']) self.permela = create_user("Permela", password="******") self.slot = create_slot("Slot") self.root.append_child(self.slot) self.text = create_textNode("Bla", "Blubb", [self.hugo]) self.slot.append_child(self.text) self.mid = create_textNode("Bla derivate", "Blubb2", [self.hugo]) self.slot.append_child(self.mid) self.text.add_derivate(self.mid, arg_type='c', title="dagegen") self.leaf1 = create_textNode("Bla leaf 1", "Blubb3", [self.hugo]) self.slot.append_child(self.leaf1) self.mid.add_derivate(self.leaf1, arg_type='c', title="dagegen2") self.mid2 = create_textNode("Bla derivate 2", "Blubb4", [self.hugo]) self.slot.append_child(self.mid2) self.mid.add_derivate(self.mid2, arg_type='c', title="dagegen") self.leaf2 = create_textNode("Bla leaf 2", "Blubb5", [self.hugo]) self.slot.append_child(self.leaf2) self.mid2.add_derivate(self.leaf2, arg_type='c', title="dagegen") self.follow = create_vote(self.hugo, [self.text, self.mid, self.leaf1, self.mid2, self.leaf2]) self.arg1 = create_argument(self.text, "con", "Wrong!", "Bad!", [self.hugo])
def setUp(self): self.hans = create_user('hans') self.hugo = create_user('hugo') self.root = get_root_node() self.slot1 = create_slot('Wahlprogramm') self.root.append_child(self.slot1) self.textnode1 = create_textNode('LangerWahlprogrammTitel', authors=[self.hans]) self.slot1.append_child(self.textnode1) self.slot2 = create_slot('Grundsatzprogramm') self.root.append_child(self.slot2) self.textnode2 = create_textNode('LangerGrundsatzTitel', authors=[self.hugo]) self.slot2.append_child(self.textnode2) self.slot3 = create_slot('Organisatorisches') self.root.append_child(self.slot3) self.textnode31 = create_textNode('Langweilig1', authors=[self.hans]) self.textnode32 = create_textNode('Langweilig2', authors=[self.hugo]) self.textnode33 = create_textNode('Langweilig3', authors=[self.hans, self.hugo]) self.slot3.append_child(self.textnode31) self.slot3.append_child(self.textnode32) self.slot3.append_child(self.textnode33) create_vote(self.hans, [self.textnode33]) self.top_slots = [self.slot1, self.slot2, self.slot3] self.short_titles = ['Wahlprogramm', 'Grundsatzprogramm', 'Organisatorisches'] self.full_titles = ['LangerWahlprogrammTitel', 'LangerGrundsatzTitel', 'Langweilig3'] self.authors = [[self.hans], [self.hugo], [self.hans, self.hugo]]
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 setUp(self): self.hans = create_user('hans') self.herbert = create_user('herbert') self.hein = create_user('hein') self.hans.profile.blocked.add(self.herbert.profile) self.hein.profile.blocked.add(self.herbert.profile) self.users = [self.hans, self.herbert, self.hein]
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_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_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.hans = create_user('hans', "he's a jolly good fellow") self.hugo = create_user('hugo', "nodescription") self.hein = create_user('hein', "password1") self.users = [self.hans, self.hugo, self.hein] self.hugo.profile.followees.add(self.hans.profile) self.hein.profile.followees.add(self.hans.profile)
def setUp(self): self.hans = create_user('hans') self.herbert = create_user('herbert') self.hein = create_user('hein') self.hugo = create_user('hugo', "nodescription") self.hans.profile.blocked.add(self.herbert.profile) self.hein.profile.blocked.add(self.herbert.profile) self.hugo.profile.followees.add(self.hans.profile) self.hein.profile.followees.add(self.hans.profile) self.users = [self.hans, self.herbert, self.hein]
def setUp(self): self.root = get_root_node() self.hugo = create_user("Hugo", password="******", groups=['texters', 'voters', 'bloggers']) create_user("Notpermitted", password="******") self.slot = create_slot("Slot") self.root.append_child(self.slot) self.text = create_textNode("Slotteria", "This is a textnode", authors=[self.hugo]) self.slot.append_child(self.text) self.url = reverse('store_text', kwargs=dict(path="Slot.1"))
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_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 setUp(self): self.hans = create_user('hans') self.hugo = create_user('hugo') self.root = get_root_node() self.slot1 = create_slot('Wahlprogramm') self.root.append_child(self.slot1) self.textnode1 = create_textNode('LangerWahlprogrammTitel', authors=[self.hans]) self.slot1.append_child(self.textnode1) self.slot2 = create_slot('Grundsatzprogramm') self.root.append_child(self.slot2) self.textnode2 = create_textNode('LangerGrundsatzTitel', authors=[self.hugo]) self.slot2.append_child(self.textnode2) self.slot3 = create_slot('Organisatorisches') self.root.append_child(self.slot3) self.textnode31 = create_textNode('Langweilig1', authors=[self.hans]) self.textnode32 = create_textNode('Langweilig2', authors=[self.hugo]) self.textnode33 = create_textNode('Langweilig3', authors=[self.hans, self.hugo]) self.slot3.append_child(self.textnode31) self.slot3.append_child(self.textnode32) self.textnode32d = create_textNode('Langweilig2 anders', authors=[self.hans, self.hugo]) self.slot3.append_child(self.textnode32d) self.textnode32.add_derivate(self.textnode32d) create_vote(self.hans, [self.textnode32, self.textnode32d]) self.slot3.append_child(self.textnode33) self.textnode33d = create_textNode('Langweilig3 anders', authors=[self.hans, self.hugo]) self.slot3.append_child(self.textnode33d) self.textnode33.add_derivate(self.textnode33d) create_spam_flag(self.hugo, [self.textnode33d]) create_vote(self.hans, [self.textnode33]) self.nodes = [self.textnode31, self.textnode32, self.textnode32d, self.textnode33, self.textnode33d] self.authorGroups = [[create_user_info(self.hans)], [create_user_info(self.hugo)], [create_user_info(self.hans), create_user_info(self.hugo)], [create_user_info(self.hans), create_user_info(self.hugo)], [create_user_info(self.hans), create_user_info(self.hugo)]] self.follows = [0, 1, 1, 1, 0] self.spamFlags = [0, 0, 0, 0, 1] self.unFollows = [0, 0, 0, 0, 1] self.newFollows = [0, 1, 0, 1, 0] self.originGroups = [[], [], ['Organisatorisches.2'], [], ['Organisatorisches.4']]
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 setUp(self): self.hans = create_user('hans', description='noneSoFar', password="******") self.karl = create_user('karl', description='none', password="******") self.anon = User.objects.filter(username='******').all()[0] self.slot = create_slot("test") self.text1 = create_textNode("Hans Text", "Ich werde anonymisiert", [self.hans]) self.text2 = create_textNode("Karls Text", "Ich werde nicht anonymisiert", [self.karl]) self.text3 = create_textNode("Gemeinsamer Text", "Anonymous wird dabei geholfen haben diesen Text zu erstellen", [self.hans, self.karl]) self.text4 = create_textNode("Gemeinsamer Text mit anonymous", "Anonymous wird dabei geholfen haben diesen Text zu erstellen", [self.hans, self.karl, self.anon])
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 setUp(self): self.root = get_root_node() self.hugo = create_user("Hugo", password="******", groups=['voters']) self.permela = create_user("Permela", password="******") self.slot = create_slot("Slot") self.root.append_child(self.slot) self.text = create_textNode("Bla", "Blubb", [self.hugo]) self.slot.append_child(self.text) self.mid = create_textNode("Bla derivate", "Blubb2", [self.hugo]) self.slot.append_child(self.mid) self.text.add_derivate(self.mid, arg_type='n') self.leaf = create_textNode("Bla leaf 1", "Blubb3", [self.hugo]) self.slot.append_child(self.leaf) self.mid.add_derivate(self.leaf, arg_type='n')
def setUp(self): self.hans = create_user('hans') self.hugo = create_user('hugo') self.root = get_root_node() self.slot1 = create_slot('Wahlprogramm') self.root.append_child(self.slot1) self.structureNode1 = create_structureNode('LangerWahlprogrammTitel', authors=[self.hans]) self.slot1.append_child(self.structureNode1) self.slot11 = create_slot('Transparenz') self.structureNode1.append_child(self.slot11) self.textnode11 = create_textNode('Traaaansparenz', authors=[self.hans]) self.slot11.append_child(self.textnode11) self.slot12 = create_slot('Bildung') self.structureNode1.append_child(self.slot12) self.textnode12 = create_textNode('Biiildung', authors=[self.hans]) self.slot12.append_child(self.textnode12) self.slot13 = create_slot('Datenschutz') self.structureNode1.append_child(self.slot13) self.textnode13 = create_textNode('Daaatenschutz', authors=[self.hans]) self.slot13.append_child(self.textnode13) self.slot2 = create_slot('Grundsatzprogramm') self.root.append_child(self.slot2) self.textnode2 = create_textNode('LangerGrundsatzTitel', authors=[self.hugo]) self.slot2.append_child(self.textnode2) self.slot3 = create_slot('Organisatorisches') self.root.append_child(self.slot3) self.textnode31 = create_textNode('Langweilig1', authors=[self.hans]) self.textnode32 = create_textNode('Langweilig2', authors=[self.hugo]) self.textnode33 = create_textNode('Langweilig3', authors=[self.hans, self.hugo]) self.slot3.append_child(self.textnode31) self.slot3.append_child(self.textnode32) self.slot3.append_child(self.textnode33) create_vote(self.hans, [self.textnode33]) self.top_slots = [self.slot1, self.slot2, self.slot3] self.child_slots = [self.slot11, self.slot12, self.slot13] self.short_titles = [ 'Wahlprogramm', 'Grundsatzprogramm', 'Organisatorisches' ] self.full_titles = [ 'LangerWahlprogrammTitel', 'LangerGrundsatzTitel', 'Langweilig3' ] self.authors = [[self.hans], [self.hugo], [self.hans, self.hugo]]
def create_some_microblogging(path=None): if User.objects.filter(username="******").count() > 0: blogger1 = User.objects.filter(username="******").all()[0] else: blogger1 = create_user("Blogger 1") create_post( "Meine Oma fährt im Hühnerstall Motorrad!" if not path else "Meine Oma erwähnt /" + path + " im Hühnerstall.", blogger1, ) if User.objects.filter(username="******").count() > 0: troll = User.objects.filter(username="******").all()[0] else: troll = create_user("Troll") if path: create_post("Ich erwähne /" + path + " um zu trollen. Lies das was ich schreibe und ärgere dich!", troll)
def setUp(self): self.max = create_user('max') self.root = get_root_node() self.bla = create_slot("Bla") self.root.append_child(self.bla) self.bla1 = create_structureNode('Bla ist Bla', "Das musste gesagt werden.", [self.max]) self.bla.append_child(self.bla1) self.blubb = create_slot("Blubb") self.bla1.append_child(self.blubb) self.blubb1 = create_textNode("Blubb ist eins", "Gesagt ist gedacht.", [self.max]) self.blubb.append_child(self.blubb1) self.blubb2 = create_textNode("Blubb die Zweite", "Geschrieben ist notiert.", [self.max]) self.blubb.append_child(self.blubb2) self.blubb2d = create_textNode("Blubb die Zweite", "Geschrieben ist anders notiert.", [self.max]) self.blubb.append_child(self.blubb2d) self.blubb2.add_derivate(self.blubb2d) self.bla2 = create_textNode("Follopp", "Globbern!", [self.max]) self.bla.append_child(self.bla2) self.bla2.add_derivate(self.blubb2) self.bla3 = create_textNode("Folloppiii", "Globbern! Den ganzen Tag.", [self.max]) self.bla.append_child(self.bla3) self.blubb2.add_derivate(self.bla3) self.bla4 = create_textNode("Flop", "Glob!", [self.max]) self.bla.append_child(self.bla4) self.bla3.add_derivate(self.bla4)
def setUp(self): self.n = create_structureNode("woot") self.n1 = create_structureNode("foo1") self.n2 = create_structureNode("foo2") self.n1.add_derivate(self.n2) self.hugo = create_user("hugo") self.v = create_vote(self.hugo, [self.n1, self.n2])
def test_recovery_resolve(self): hans = create_user('hans', password="******") act = PasswordRecovery.create(hans) pw = act.resolve() self.assertTrue(pw) self.assertIsNone(authenticate(username='******', password='******')) self.assertEqual(authenticate(username='******', password=pw), hans)
def setUp(self): self.hugo = create_user('hugo') self.herbert = create_user('herbert') self.foo1 = create_nodes_for_path('foo.1') self.foo1bar1 = create_nodes_for_path('foo.1/bar.1') self.schema_skeleton = { 'author': self.hugo.id, 'location': self.foo1.id, 'type': "userpost", 'template_text': "some text", 'mentions': [], 'references': [], 'answer_to': None }
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 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 create_initial_data(): root = get_root_node() decided = create_user("Beschluss_Programm", description="Diese Vorschläge wurden in ihrer urspünglichen " "Fassung schon von einem Parteitag beschlossen. " "Weiterentwicklungen dieser Vorschläge sind " "natürlich kein beschlossenes Programm.", groups=['texters', 'voters', 'bloggers']) with open(project_path("initial_data/root.txt"), 'r') as f: lines = f.readlines() for l in lines: if comment_line_pattern.match(l): continue slot_name, src_file = l.split() assert re.match('^' + SHORT_TITLE + '$', slot_name), \ "Invalid short title '%s'." % slot_name src_path = project_path(os.path.join('initial_data', src_file)) assert os.path.exists(src_path), \ "Source file not found: '%s'." % src_path print("Creating '%s' from file '%s'." % (slot_name, src_path)) slot = create_slot(slot_name) root.append_child(slot) with open(src_path, 'r') as src: schema = parse(unicode(src.read(), encoding='utf-8'), slot.title) create_structure_from_structure_node_schema(schema, slot, decided)
def setUp(self): self.user_max = create_user("max",password="******") self.user_maria = create_user("Maria") root = backend.get_root_node() slot1 = create_slot("Bla") root.append_child(slot1) self.text_node1 = create_textNode("Whatever","Testtext",[self.user_max]) slot1.append_child(self.text_node1) slot2 = create_slot("Blubb") root.append_child(slot2) text_node2 = create_textNode("Whatever2","Testtext Nummer 2",[self.user_max]) slot2.append_child(text_node2)
def test_store_microblogging(self): hugo = create_user('hugo', password='******') foo1 = create_nodes_for_path('foo.1') self.assertTrue(self.client.login(username="******", password="******")) response = self.client.post( reverse('store_microblogging', kwargs={'path': 'foo.1'}), json.dumps({ 'microblogText': 'test stuff on http://testserver/foo.1/ and reference /foo.1 and also @hugo' }), content_type="application/json") res = json.loads(response.content) self.assertIn("storeMicrobloggingResponse", res) self.assertEqual(hugo.microblogging_posts.count(), 1) p = hugo.microblogging_posts.all()[0] self.assertEqual(p.location, foo1) self.assertEqual(p.author, hugo) self.assertEqual(p.post_type, Post.USER_POST) self.assertIn(hugo, p.mentions.all()) self.assertIn(foo1, p.node_references.all()) self.assertEqual( p.text_template, "test stuff on {n0}/ and reference {n0} and also {u0}") self.assertTrue(p.text_cache != "")
def create_alternatives_for_urheberrecht(path): ulf = create_user("ulf") timo = create_user("timo") slot_path = path.rsplit(".", 1)[0] slot = get_node_for_path(slot_path) w1 = "Reform des Urheberrechts sollte von der Basis kommen." a1 = create_structureNode("Urheberrecht", w1, authors=[ulf]) slot.append_child(a1) w2a = "Abschaffung des Urheberrechts!" a2a = create_structureNode("Kein Urheberrecht", w2a, authors=[ulf]) slot.append_child(a2a) w2b = "Völlige Abschaffung des Urheber- und Patentrechts!" a2b = create_structureNode("Kein Urheberrecht", w2b, authors=[ulf]) slot.append_child(a2b) arga = a2a.add_derivate( a2b, "con", "Patentrecht ist genauso böse", "Das patentrecht ist mindestens genauso schlimm und muss auch weg!", [ulf], ) w2c = "Völlige Abschaffung des Urheber- und Patentrechts! Außerdem Todesstrafe für alle Patentanwälte." a2c = create_structureNode("Kein Urheberrecht", w2c, authors=[timo]) slot.append_child(a2c) argb = a2b.add_derivate(a2c, "con", "Patentanwälte stinken!", "Dieses Pack gehört ausgerottet!", [timo]) # create votes original = get_node_for_path(path) hugo = create_user("hugo") hans = create_user("hans") hein = create_user("hein") create_vote(ulf, [a1]) create_vote(ulf, [a2a, a2b]) create_vote(timo, [a2c]) create_vote(hugo, [original]) create_vote(hein, [original]) create_vote(hans, [a1]) create_vote(hans, [a2b]) create_vote(hans, [arga]) create_vote(ulf, [arga]) create_spam_flag(hein, [argb]) create_spam_flag(hein, [a2c])
def setUp(self): self.hans = create_user('hans') self.hugo = create_user('hugo') self.root = get_root_node() self.slot1 = create_slot('Wahlprogramm') self.root.append_child(self.slot1) self.structureNode1 = create_structureNode('LangerWahlprogrammTitel', authors=[self.hans]) self.slot1.append_child(self.structureNode1) self.slot11 = create_slot('Transparenz') self.structureNode1.append_child(self.slot11) self.textnode11 = create_textNode('Traaaansparenz', authors=[self.hans]) self.slot11.append_child(self.textnode11) self.slot12 = create_slot('Bildung') self.structureNode1.append_child(self.slot12) self.textnode12 = create_textNode('Biiildung', authors=[self.hans]) self.slot12.append_child(self.textnode12) self.slot13 = create_slot('Datenschutz') self.structureNode1.append_child(self.slot13) self.textnode13 = create_textNode('Daaatenschutz', authors=[self.hans]) self.slot13.append_child(self.textnode13) self.slot2 = create_slot('Grundsatzprogramm') self.root.append_child(self.slot2) self.textnode2 = create_textNode('LangerGrundsatzTitel', authors=[self.hugo]) self.slot2.append_child(self.textnode2) self.slot3 = create_slot('Organisatorisches') self.root.append_child(self.slot3) self.textnode31 = create_textNode('Langweilig1', authors=[self.hans]) self.textnode32 = create_textNode('Langweilig2', authors=[self.hugo]) self.textnode33 = create_textNode('Langweilig3', authors=[self.hans, self.hugo]) self.slot3.append_child(self.textnode31) self.slot3.append_child(self.textnode32) self.slot3.append_child(self.textnode33) create_vote(self.hans, [self.textnode33]) self.top_slots = [self.slot1, self.slot2, self.slot3] self.child_slots = [self.slot11, self.slot12, self.slot13] self.short_titles = ['Wahlprogramm', 'Grundsatzprogramm', 'Organisatorisches'] self.full_titles = ['LangerWahlprogrammTitel', 'LangerGrundsatzTitel', 'Langweilig3'] self.authors = [[self.hans], [self.hugo], [self.hans, self.hugo]]
def setUp(self): self.root = get_root_node() self.mustermann = create_user("Mustermann") self.slot = create_slot("Flopp") self.root.append_child(self.slot) self.text1 = create_textNode("Initial Text", "Dumdidum", [self.mustermann]) self.slot.append_child(self.text1)
def setUp(self): self.hugo = create_user('hugo') self.hans = create_user('hans') # create nodes self.root = get_root_node() self.foo = create_slot('foo') self.foo1 = create_structureNode('FooooBar') # add arguments self.foo_pro = create_argument(type='pro', title="geil", authors=[self.hugo]) self.foo1.append_argument(self.foo_pro) self.foo_neut = create_argument(type='neut', title="ist", authors=[self.hans]) self.foo1.append_argument(self.foo_neut) self.foo_con = create_argument(type='con', title="geiz", authors=[self.hugo, self.hans]) self.foo1.append_argument(self.foo_con) # summary variables self.foo_arguments = [self.foo_pro, self.foo_neut, self.foo_con] self.arg_titles = ['geil', 'ist', 'geiz'] self.arg_authors = [[self.hugo], [self.hans], [self.hugo, self.hans]]
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_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 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 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_post_node_was_flagged_message(self): hugo = create_user('Hugo') post = post_node_was_flagged_message('/', hugo) self.assertEqual(post.author, get_system_user()) self.assertEqual(post.location, get_root_node()) self.assertEqual(post.post_type, Post.SPAM_MARKED) self.assertIn(hugo, post.mentions.all()) self.assertEqual( post.text_cache, '<span style="color: gray;">Hinweis:</span> ' + '<a href="/user/Hugo">@Hugo</a> hat <a href="/">ROOT' '<span class="nodeIndex">1</span></a> als Spam markiert.')
def setUp(self): self.hugo = create_user('hugo') self.hans = create_user('hans') # create nodes self.root = get_root_node() self.foo = create_slot('foo') self.root.append_child(self.foo) self.foo1 = create_structureNode('FooooBar') self.foo.append_child(self.foo1) # add arguments self.foo_pro = create_argument(self.foo1, arg_type='pro', title="geil", authors=[self.hugo]) self.foo_neut = create_argument(self.foo1, arg_type='neut', title="ist", authors=[self.hans]) self.foo_con = create_argument(self.foo1, arg_type='con', title="geiz", authors=[self.hugo, self.hans]) # summary variables self.foo_arguments = [self.foo_pro, self.foo_neut, self.foo_con] self.arg_titles = ['geil', 'ist', 'geiz'] self.arg_authors = [[self.hugo], [self.hans], [self.hugo, self.hans]]
def setUp(self): self.hans = create_user('hans', description='noneSoFar', password="******") self.karl = create_user('karl', description='none', password="******") self.anon = User.objects.filter(username='******').all()[0] self.slot = create_slot("test") self.text1 = create_textNode("Hans Text", "Ich werde anonymisiert", [self.hans]) self.text2 = create_textNode("Karls Text", "Ich werde nicht anonymisiert", [self.karl]) self.text3 = create_textNode("Gemeinsamer Text", "Anonymous wird dabei geholfen haben " "diesen Text zu erstellen", [self.hans, self.karl]) self.text4 = create_textNode("Gemeinsamer Text mit anonymous", "Anonymous wird dabei geholfen haben " "diesen Text zu erstellen", [self.hans, self.karl, self.anon])
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_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)