Exemplo n.º 1
0
    def test_title_link_collision(self):
        i = interpretation.submit(
                           title=u'untitled',
                           author='Anonymous',
                           type=interpretation.T_TEXT,
                           content='fnord')
        self.assertEquals(i.title_link, 'untitled')

        j = interpretation.submit(
                           title=u'untitled',
                           author='Anonymous',
                           type=interpretation.T_TEXT,
                           content='fnord')
        self.assertEquals(j.title_link, 'untitled-1')
Exemplo n.º 2
0
 def _data(self):
     """submit a new interpretation"""
     i = interpretation.submit(
              title=self.request.get('title'),
              author=self.request.get('author'),
              type=self.request.get('type'),
              content=self.request.get('content'))
     task = taskqueue.Task(
         method='GET',
         params={'key_string': str(i.key())})
     task.add(queue_name='new-interpretation')
     return i
Exemplo n.º 3
0
    def test_submit(self):
        i = interpretation.submit(title=u"untitled", author="Anonymous", type=interpretation.T_TEXT, content="fnord")

        self.assertEquals(comment.count(i), 0)

        c = comment.submit(author="Anonymous", content="yadda", interpretation_key_string=str(i.key()))

        self.assertEquals(comment.count(i), 1)

        l = comment.list_comments(str(i.key()))
        self.assertEquals(len(l), 1)
        self.assertEquals(l[0].is_active, True)
        self.assertEquals(l[0].author, "Anonymous")
        self.assertEquals(l[0].content, "yadda")
Exemplo n.º 4
0
    def test_submit_approve(self):
        ## submitting an interpretation should create an inactive one
        i = interpretation.submit(
                           title=u'Test',
                           author='Anonymous',
                           type=interpretation.T_TEXT,
                           content='fnord')
        self.assertFalse(i.is_active)

        ## fetching it is possible if specific key is provided
        self.assertEquals(interpretation.count({'key_string': str(i.key())}), 1)
        for j in [interpretation.poot({'key_string': str(i.key())}), interpretation.list_interpretations({'key_string': str(i.key())}, 20)[0]]:
            ## and the fetched interpretation should be identical
            self.assertEquals(i.title_link, j.title_link)
            self.assertEquals(i.title, j.title)
            self.assertEquals(i.type, j.type)
            self.assertEquals(i.content_type, j.content_type)
            self.assertEquals(i.content, j.content)
            self.assertEquals(i.is_active, j.is_active)
            self.assertEquals(i.author, j.author)

        ## even with a title_link (unique) fetch, can't see it yet:
        self.assertEquals(interpretation.count({'title_link': i.title_link}), 0)
        self.assertEquals(interpretation.list_interpretations({'title_link': i.title_link}, 20), [])
        self.assertEquals(interpretation.list_pages({'title_link': i.title_link}, 20), [])
        self.assertEquals(interpretation.poot({'title_link': i.title_link}), None)

        ## with an author fetch, can't see it yet:
        self.assertEquals(interpretation.count({'author': i.author}), 0)
        self.assertEquals(interpretation.list_interpretations({'author': i.author}, 20), [])
        self.assertEquals(interpretation.list_pages({'author': i.author}, 20), [])
        self.assertEquals(interpretation.poot({'author': i.author}), None)

        ## with a type fetch, can't see it yet:
        self.assertEquals(interpretation.count({'type': i.type}), 0)
        self.assertEquals(interpretation.list_interpretations({'type': i.type}, 20), [])
        self.assertEquals(interpretation.list_pages({'type': i.type}, 20), [])
        self.assertEquals(interpretation.poot({'type': i.type}), None)

        ## but fetching without a key should return nothing
        self.assertEquals(interpretation.count({}), 0)
        self.assertEquals(interpretation.list_interpretations({}, 20), [])
        self.assertEquals(interpretation.list_pages({}, 20), [])
        self.assertEquals(interpretation.poot({}), None)

        ## attempting to approve with no owner_baton or bunk owner_baton should fail
        self.assertRaises(interpretation.BadOwnerBaton, interpretation.approve, i, None)
        self.assertRaises(interpretation.BadOwnerBaton, interpretation.approve, i, "blah blah blah")

        ## approving it should activate it; should now be able to see it via title_link fetches
        interpretation.approve(i, i.owner_baton)
        self.assertTrue(i.is_active)
        self.assertEquals(interpretation.count({'title_link': i.title_link}), 1)
        self.assertEquals(interpretation.count({'author': i.author}), 1)
        for j in [interpretation.poot({'key_string': str(i.key())}), interpretation.list_interpretations({'key_string': str(i.key())}, 20)[0], interpretation.poot({'title_link': i.title_link}), interpretation.list_interpretations({'title_link': i.title_link}, 20)[0], interpretation.poot({'author': i.author}), interpretation.list_interpretations({'author': i.author}, 20)[0], interpretation.poot({'type': i.type}), interpretation.list_interpretations({'type': i.type}, 20)[0]]:
            self.assertEquals(i.is_active, j.is_active)

        ## now fetching without a key should bring it up
        self.assertEquals(interpretation.count({}), 1)
        k = interpretation.poot({})
        self.assertEquals(str(i.key()), str(k.key()))
        l = interpretation.list_interpretations({}, 20)
        self.assertEquals(str(i.key()), str(l[0].key()))
        lp = interpretation.list_pages({}, 20)
        self.assertEquals(lp[0]['page_number'], 1)
        self.assertEquals(lp[0]['offset_key_string'], str(i.key()))
Exemplo n.º 5
0
def _stc(_type, _content):
    return interpretation.submit(title=u'untitled', author='anonymous', type=_type, content=_content)