Ejemplo n.º 1
0
    def test_bad_title_link(self):
        ## none
        self.assertEquals(interpretation.poot({'title_link':None}), None)
        self.assertEquals(interpretation.count({'title_link':None}), 0)
        self.assertEquals(interpretation.list_interpretations({'title_link':None}, 20), [])

        ## refers to no element
        self.assertEquals(interpretation.poot({'title_link':'foo-bar-baz'}), None)
        self.assertEquals(interpretation.count({'title_link':'foo-bar-baz'}), 0)
        self.assertEquals(interpretation.list_interpretations({'title_link':'foo-bar-baz'}, 20), [])
Ejemplo n.º 2
0
    def test_bad_key(self):
        ## none
        self.assertEquals(interpretation.poot({'key_string':None}), None)
        self.assertEquals(interpretation.count({'key_string':None}), 0)
        self.assertEquals(interpretation.list_interpretations({'key_string':None}, 20), [])

        ## does not look like a real key
        self.assertEquals(interpretation.poot({'key_string':'asdf'}), None)
        self.assertEquals(interpretation.count({'key_string':'asdf'}), 0)
        self.assertEquals(interpretation.list_interpretations({'key_string':'asdf'}, 20), [])

        ## looks like a real key, but refers to no element
        self.assertEquals(interpretation.poot({'key_string':'aglwb290LXBvb3RyFAsSDkludGVycHJldGF0aW9uGAIM'}), None)
        self.assertEquals(interpretation.count({'key_string':'aglwb290LXBvb3RyFAsSDkludGVycHJldGF0aW9uGAIM'}), 0)
        self.assertEquals(interpretation.list_interpretations({'key_string':'aglwb290LXBvb3RyFAsSDkludGVycHJldGF0aW9uGAIM'}, 20), [])
Ejemplo n.º 3
0
Archivo: i.py Proyecto: dlowe/pootpoot
    def get(self):
        """fetch the content of a single interpretation by key"""

        status       = None
        content      = None
        content_type = None
        i            = None

        match = re.search('/([^/]+)$', self.request.path)
        if match:
            key_string = match.group(1)
            i = interpretation.poot({ 'key_string': key_string })
        if i == None:
            status = 404
            content_type = 'text/plain'
            content      = "{\"error\":\"Not Found\"}"
        else:
            if 'Cache-Control' in self.response.headers:
                del self.response.headers['Cache-Control']
            self.response.headers.add_header('Cache-Control', 'public')
            self.response.headers.add_header('Expires',
                time.strftime('%a, %d %b %Y %H:%M:%S GMT',
                              time.localtime(time.time() + EXPIRE)))
            status       = 200
            content_type = i.content_type
            content      = i.content

        self.response.set_status(status)
        if 'Content-Type' in self.response.headers:
            del self.response.headers['Content-Type']
        self.response.headers.add_header('Content-Type', content_type)
        self.response.out.write(content)
Ejemplo n.º 4
0
 def _data(self):
     """fetch and delete by key"""
     i = interpretation.poot(
         { 'key_string': self.request.get('key_string') })
     if i != None:
         interpretation.delete(i, self.request.get('owner_baton'))
     return i
Ejemplo n.º 5
0
    def get(self):
        """offline processing of a new interpretation"""

        i = interpretation.poot({ 'key_string': self.request.get('key_string') })
        if i != None:
            if (('BITLY_KEY' in integration.INTEGRATIONS)
              and ('BITLY_LOGIN' in integration.INTEGRATIONS)):
                url = 'http://api.bit.ly/shorten?version=2.0.1&history=1'
                url = url + '&login=%s&apiKey=%s&longUrl=%s' % (
                    integration.INTEGRATIONS['BITLY_LOGIN'],
                    integration.INTEGRATIONS['BITLY_KEY'],
                    urllib.quote_plus('%sinterpretation/%s.html'
                        % (integration.INTEGRATIONS['APP_ROOT_URL'], i.title_link)))
                result = urlfetch.fetch(url, method='GET')
                if result.status_code == 200:
                    ## "shortUrl": "http://bit.ly/1R2vI8",
                    match = re.search('shortUrl.*"(http://[^"]*)"', result.content)
                    if match:
                        i.short_url = match.group(1)
                        logging.warn(i.short_url)
                        i.put()

        self.response.set_status(200)
        self.response.out.write('ok')
Ejemplo n.º 6
0
 def test_unicode(self):
     i = _stc(interpretation.T_TEXT, unicode.encode(u'わたし', 'utf-8'))
     self.assertEquals(i.content_type, 'text/plain')
     j = interpretation.poot({'key_string': str(i.key())})
     self.assertEquals(j.content, unicode.encode(u'わたし', 'utf-8'))
Ejemplo n.º 7
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()))
Ejemplo n.º 8
0
 def _data(self):
     """fetch random interpretation"""
     return interpretation.poot(_get_filter_arguments(self.request))