def test_get_newfollows_on_node_with_same_votes_than_source_returns_0(self):
n = create_structureNode('Foo')
n2 = create_structureNode('Foo2')
n.add_derivate(n2)
create_vote(self.hans, [n, n2])
create_vote(self.hugo, [n, n2])
self.assertEqual(n2.get_newfollows(), 0)
def test_get_unfollows_with_an_unfollow_returns_1(self):
n = create_structureNode('Foo')
n2 = create_structureNode('Foo2')
n.add_derivate(n2)
create_vote(self.hans, [n])
create_vote(self.hugo, [n, n2])
self.assertEqual(n2.get_unfollows(), 1)
def test_get_newfollows_does_count_votes_and_not_users(self):
n = create_structureNode('Foo')
n2 = create_structureNode('Foo2')
n.add_derivate(n2)
create_vote(self.hans, [n])
create_vote(self.hans, [n2])
self.assertEqual(n2.get_newfollows(), 1)
def test_get_newfollows_with_2_newfollows_returns_2(self):
n = create_structureNode('Foo')
n2 = create_structureNode('Foo2')
n.add_derivate(n2)
create_vote(self.hans, [n2])
create_vote(self.hugo, [n2])
self.assertEqual(n2.get_newfollows(), 2)
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 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_add_derivate_copies_arguments(self):
s = create_structureNode("Source", authors=[self.hans])
self.foo.append_child(s)
d = create_structureNode("Derivate", authors=[self.hans])
self.foo.append_child(d)
a = create_argument(s, arg_type='p', title="myArg", text="cool",
authors=[self.hugo])
self.assertEqual(s.arguments.count(), 1)
self.assertEqual(s.arguments.all()[0], a)
s.add_derivate(d, arg_type='c', title="yourArg", text="ument",
authors=[self.hans])
self.assertEqual(s.arguments.count(), 2)
sa1, sa2 = s.arguments.order_by('index')
self.assertEqual(sa1, a)
self.assertEqual(sa2.arg_type, 'c')
self.assertEqual(sa2.title, 'yourArg')
self.assertEqual(sa2.text.text, 'ument')
self.assertEqual(sa2.text.authors.count(), 1)
self.assertIn(self.hans, sa2.text.authors.all())
self.assertEqual(d.arguments.count(), 1)
da1, = d.arguments.order_by('index')
self.assertEqual(da1.arg_type, 'p')
self.assertEqual(da1.title, 'myArg')
self.assertEqual(da1.text.text, 'cool')
self.assertEqual(da1.text.authors.count(), 1)
self.assertIn(self.hugo, da1.text.authors.all())
def test_get_unfollows_counts_votes_from_multiple_sources_only_once(self):
n1 = create_structureNode('Foo1')
n2 = create_structureNode('Foo2')
d = create_structureNode('Foo12')
n1.add_derivate(d)
n2.add_derivate(d)
create_vote(self.hans, [n1, n2])
self.assertEqual(d.get_unfollows(), 1)
def test_add_derivate_adds_only_correct_derivation(self):
n = create_structureNode("Source", authors=[self.hans])
self.foo.append_child(n)
d = create_structureNode("Derivate", authors=[self.hans])
self.foo.append_child(d)
n.add_derivate(d, arg_type='n')
self.assertIn(d, n.derivates.all())
self.assertIn(n, d.sources.all())
no = Derivation.objects.filter(source=n, derivate=d)
self.assertTrue(no.count() == 1)
self.assertEqual(n, no.all()[0].argument.concerns)
self.assertIn(no[0], n.derivative_order_set.all())
self.assertIn(no[0], d.source_order_set.all())
def test_add_derivate_creates_commit_argument(self):
s = create_structureNode("Source", authors=[self.hans])
self.foo.append_child(s)
d = create_structureNode("Derivate", authors=[self.hans])
self.foo.append_child(d)
s.add_derivate(d, arg_type='c', title="arg", text="ument",
authors=[self.hugo])
no = Derivation.objects.filter(source=s, derivate=d)
self.assertTrue(no.count() == 1)
no = no[0]
self.assertEqual(no.argument.arg_type, 'c')
self.assertEqual(no.argument.title, 'arg')
self.assertEqual(no.argument.text.text, 'ument')
self.assertEqual(no.argument.text.authors.count(), 1)
self.assertIn(self.hugo, no.argument.text.authors.all())
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 generate_refinement(origin, proposal, argument, slot, user):
derivate = create_structureNode(long_title=proposal['heading'],
text=proposal['text'],
authors=[user])
slot.append_child(derivate)
create_vote(user, [derivate]) # auto-follow
for child in proposal['subsections']:
if not re.match(SHORT_TITLE, child['shorttitle']):
raise InvalidShortTitle('Invalid short-title: "{}"'.format(
child['shorttitle']))
if 'text' in child:
if origin.children.filter(title=child['shorttitle']).count() > 0:
raise InvalidShortTitle(
'ShortTitle {} is already taken'.format(
child['shorttitle']))
child_slot = create_slot(child['shorttitle'])
derivate.append_child(child_slot)
generate_proposal_node_with_subsections(child_slot, child, user)
else:
child_slots = origin.children.filter(title=child['shorttitle'])
if child_slots.count() == 0:
raise InvalidShortTitle('Unknown short title {}'.format(
child['shorttitle']))
derivate.append_child(child_slots[0])
origin.add_derivate(derivate,
arg_type="con",
title=argument['heading'],
text=argument['text'],
authors=[user])
return derivate
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 generate_refinement(origin, proposal, argument, slot, user):
derivate = create_structureNode(
long_title=proposal['heading'], text=proposal['text'], authors=[user])
slot.append_child(derivate)
create_vote(user, [derivate]) # auto-follow
for child in proposal['subsections']:
if not re.match(SHORT_TITLE, child['shorttitle']):
raise InvalidShortTitle('Invalid short-title: "{}"'.
format(child['shorttitle']))
if 'text' in child:
if origin.children.filter(title=child['shorttitle']).count() > 0:
raise InvalidShortTitle('ShortTitle {} is already taken'.
format(child['shorttitle']))
child_slot = create_slot(child['shorttitle'])
derivate.append_child(child_slot)
generate_proposal_node_with_subsections(child_slot, child, user)
else:
child_slots = origin.children.filter(title=child['shorttitle'])
if child_slots.count() == 0:
raise InvalidShortTitle('Unknown short title {}'.
format(child['shorttitle']))
derivate.append_child(child_slots[0])
origin.add_derivate(derivate,
arg_type="con",
title=argument['heading'],
text=argument['text'],
authors=[user])
return derivate
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 test_add_derivate(self):
n = create_structureNode("Source", authors=[self.hans])
d = create_structureNode("Derivate", authors=[self.hans])
a = create_argument()
n.add_derivate(a, d)
self.assertIn(d, n.derivates.all())
self.assertIn(n, d.sources.all())
no = Derivation.objects.filter(source=n, derivate=d)
self.assertTrue(no.count() == 1)
self.assertEqual(no[0].argument, a)
self.assertIn(no[0], n.derivative_order_set.all())
self.assertIn(no[0], d.source_order_set.all())
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 fork_node_and_add_slot(path, user, wiki_text):
source_node = assert_node_for_path(path)
authors = list(source_node.text.authors.all()) + [user]
title = source_node.title
# create fork
fork = create_structureNode(title,
source_node.text.text,
authors)
parent_slot_path = path.rsplit('.', 1)[0]
parent_slot = get_node_for_path(parent_slot_path)
parent_slot.append_child(fork)
fork_path = parent_slot_path + '.' + str(fork.get_index(parent_slot))
short_titles = set()
for slot in get_ordered_children_for(source_node):
fork.append_child(slot)
short_titles.add(slot.title)
# create new slot plus node
schema = parse(wiki_text, 'foo')
short_title = turn_into_valid_short_title(schema['title'], short_titles)
new_slot = create_slot(short_title)
fork.append_child(new_slot)
node = create_structure_from_structure_node_schema(schema, new_slot, user)
arg_title = "Abschnitt über '{0}' fehlt.".format(schema['title'])
source_node.add_derivate(fork, 'con', arg_title, authors=[user])
# auto follow
follow_node(fork, user.id)
follow_node(node, user.id)
return fork_path
def test_append_child_slot_adds_all_paths(self):
slot = create_slot('Foo')
self.root.append_child(slot)
sn1 = create_structureNode("Foobarbaz1")
slot.append_child(sn1)
sn2 = create_structureNode("Foobarbaz2")
slot.append_child(sn2)
slot_t = create_slot('Ba')
sn1.append_child(slot_t)
sn2.append_child(slot_t)
sn_test = create_structureNode("Barbaren")
slot_t.append_child(sn_test)
self.assertEqual(sn_test, PathCache.objects.get(path='Foo.1/Ba.1').node)
self.assertEqual(sn_test, PathCache.objects.get(path='Foo.2/Ba.1').node)
def test_add_derivate_creates_transitive_votes(self):
n = create_structureNode("Source", authors=[self.hans])
self.foo.append_child(n)
v1 = create_vote(self.hans, [n])
v2 = create_vote(self.hugo, [n])
d = create_structureNode("Derivate", authors=[self.hans])
self.foo.append_child(d)
n.add_derivate(d, arg_type='n')
self.assertIn(n, v1.nodes.all())
self.assertIn(d, v1.nodes.all())
self.assertEqual(v1.nodes.count(), 2)
self.assertIn(n, v2.nodes.all())
self.assertIn(d, v2.nodes.all())
self.assertEqual(v2.nodes.count(), 2)
self.assertEqual(d.votes.count(), 2)
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 test_append_child_structure_node_adds_to_path_cache(self):
slot = create_slot('Foo')
self.root.append_child(slot)
sn = create_structureNode("Foobarbaz")
slot.append_child(sn)
self.assertEqual(sn, PathCache.objects.get(path='Foo.1').node)
self.assertEqual('Foo.1', PathCache.objects.get(node=sn).path)
def test_creating_an_argument_adds_to_path_cache(self):
slot = create_slot('Foo')
self.root.append_child(slot)
sn = create_structureNode("Foobarbaz1")
slot.append_child(sn)
a = create_argument(sn, arg_type='con')
node_a = Node.objects.get(id=a.id)
self.assertEqual(node_a, PathCache.objects.get(path='Foo.1.con.1').node)
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 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 generate_proposal_node_with_subsections(slot, proposal, user):
proposal_node = create_structureNode(
long_title=proposal['heading'], text=proposal['text'], authors=[user])
slot.append_child(proposal_node)
create_vote(user, [proposal_node]) # auto-follow
for child in proposal['subsections']:
if not re.match(SHORT_TITLE, child['shorttitle']):
raise InvalidShortTitle('Invalid short-title: "{}"'.
format(child['shorttitle']))
child_slot = create_slot(child['shorttitle'])
proposal_node.append_child(child_slot)
generate_proposal_node_with_subsections(child_slot, child, user)
return proposal_node
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 generate_proposal_node_with_subsections(slot, proposal, user):
proposal_node = create_structureNode(long_title=proposal['heading'],
text=proposal['text'],
authors=[user])
slot.append_child(proposal_node)
create_vote(user, [proposal_node]) # auto-follow
for child in proposal['subsections']:
if not re.match(SHORT_TITLE, child['shorttitle']):
raise InvalidShortTitle('Invalid short-title: "{}"'.format(
child['shorttitle']))
child_slot = create_slot(child['shorttitle'])
proposal_node.append_child(child_slot)
generate_proposal_node_with_subsections(child_slot, child, user)
return proposal_node
def setUp(self):
self.hugo = create_user('hugo')
# 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(type='pro', text="weils geil ist", authors=[self.hugo])
self.foo1.append_argument(self.foo_pro)
self.foo_neut = create_argument(type='neut', text="kann noch geiler werden", authors=[self.hugo])
self.foo1.append_argument(self.foo_neut)
self.foo_con = create_argument(type='con', text="is aber leider root", authors=[self.hugo])
self.foo1.append_argument(self.foo_con)
# summary variables
self.foo_arguments = [self.foo_pro, self.foo_neut, self.foo_con]
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 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.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.hugo = create_user('hugo')
# 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',
text="weils geil ist",
authors=[self.hugo])
self.foo_neut = create_argument(self.foo1,
arg_type='neut',
text="kann noch geiler werden",
authors=[self.hugo])
self.foo_con = create_argument(self.foo1,
arg_type='con',
text="is aber leider root",
authors=[self.hugo])
# summary variables
self.foo_arguments = [self.foo_pro, self.foo_neut, self.foo_con]
def test_get_newfollows_without_sources_returns_number_of_follows(self):
n = create_structureNode('Foo')
create_vote(self.hans, [n])
create_vote(self.hugo, [n])
self.assertEqual(n.get_newfollows(), 2)
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',
text="Einleitungstext",
authors=[self.hans])
self.slot1.append_child(self.structureNode1)
self.slot11 = create_slot('Transparenz')
self.structureNode1.append_child(self.slot11)
self.structureNode11 = create_structureNode(
'Traaaansparenz',
text="Transparenz ist wichtig.",
authors=[self.hans])
self.slot11.append_child(self.structureNode11)
self.slot111 = create_slot('Ebene_3')
self.structureNode11.append_child(self.slot111)
self.structureNode111 = create_structureNode(
'Eeeebeneee 3',
authors=[self.hans])
self.slot111.append_child(self.structureNode111)
self.slot1111 = create_slot('Ebene_4')
self.structureNode111.append_child(self.slot1111)
self.structureNode1111 = create_structureNode(
'Eeeebeneee 4',
authors=[self.hans])
self.slot1111.append_child(self.structureNode1111)
self.slot11111 = create_slot('Ebene_5')
self.structureNode1111.append_child(self.slot11111)
self.structureNode11111 = create_structureNode(
'Eeeebeneee 5',
authors=[self.hans])
self.slot11111.append_child(self.structureNode11111)
self.slot111111 = create_slot('Ebene_6')
self.structureNode11111.append_child(self.slot111111)
self.structureNode111111 = create_structureNode(
'Eeeebeneee 6',
authors=[self.hans])
self.slot111111.append_child(self.structureNode111111)
self.slot1111111 = create_slot('Ebene_7')
self.structureNode111111.append_child(self.slot1111111)
self.textnode1111111 = create_textNode(
'Traaaansparenz',
text="Auf Ebene 7.",
authors=[self.hans])
self.slot1111111.append_child(self.textnode1111111)
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', text="Blubb.", authors=[self.hans])
self.slot13.append_child(self.textnode13)
self.textnode13_a1 = create_argument(
self.textnode13, arg_type='con', title='Dagegen',
text="...denn ihr seid dafür", authors=[self.hugo])
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]]
self.maxDiff = None
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',
text="Einleitungstext",
authors=[self.hans])
self.slot1.append_child(self.structureNode1)
self.slot11 = create_slot('Transparenz')
self.structureNode1.append_child(self.slot11)
self.structureNode11 = create_structureNode(
'Traaaansparenz',
text="Transparenz ist wichtig.",
authors=[self.hans])
self.slot11.append_child(self.structureNode11)
self.slot111 = create_slot('Ebene_3')
self.structureNode11.append_child(self.slot111)
self.structureNode111 = create_structureNode('Eeeebeneee 3',
authors=[self.hans])
self.slot111.append_child(self.structureNode111)
self.slot1111 = create_slot('Ebene_4')
self.structureNode111.append_child(self.slot1111)
self.structureNode1111 = create_structureNode('Eeeebeneee 4',
authors=[self.hans])
self.slot1111.append_child(self.structureNode1111)
self.slot11111 = create_slot('Ebene_5')
self.structureNode1111.append_child(self.slot11111)
self.structureNode11111 = create_structureNode('Eeeebeneee 5',
authors=[self.hans])
self.slot11111.append_child(self.structureNode11111)
self.slot111111 = create_slot('Ebene_6')
self.structureNode11111.append_child(self.slot111111)
self.structureNode111111 = create_structureNode('Eeeebeneee 6',
authors=[self.hans])
self.slot111111.append_child(self.structureNode111111)
self.slot1111111 = create_slot('Ebene_7')
self.structureNode111111.append_child(self.slot1111111)
self.textnode1111111 = create_textNode('Traaaansparenz',
text="Auf Ebene 7.",
authors=[self.hans])
self.slot1111111.append_child(self.textnode1111111)
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',
text="Blubb.",
authors=[self.hans])
self.slot13.append_child(self.textnode13)
self.textnode13_a1 = create_argument(self.textnode13,
arg_type='con',
title='Dagegen',
text="...denn ihr seid dafür",
authors=[self.hugo])
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]]
self.maxDiff = None
