arno/isso
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

replace assert foo == bar with appropriate self.assert$Foo calls

Browse Source 
except for test_migration because there are improved tests available
in the feature/cli branch
This commit is contained in:
Martin Zimmermann 2014-02-04 15:05:32 +01:00
parent b100517e4b
commit 5efa81b57e
5 changed files with 157 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
specs/test_comments.py
View File

@ -5,7 +5,11 @@ from __future__ import unicode_literals
import os import os
import json import json
import tempfile import tempfile
import unittest
try:
import unittest2 as unittest
except ImportError:
import unittest
try: try:
from urllib.parse import urlencode from urllib.parse import urlencode
@ -49,36 +53,36 @@ class TestComments(unittest.TestCase):
self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'}))
r = self.get('/id/1') r = self.get('/id/1')
assert r.status_code == 200 self.assertEqual(r.status_code, 200)
rv = loads(r.data) rv = loads(r.data)
assert rv['id'] == 1 self.assertEqual(rv['id'], 1)
assert rv['text'] == '<p>Lorem ipsum ...</p>' self.assertEqual(rv['text'], '<p>Lorem ipsum ...</p>')
def testCreate(self): def testCreate(self):
rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'}))
assert rv.status_code == 201 self.assertEqual(rv.status_code, 201)
assert any(filter(lambda header: header[0] == 'Set-Cookie', rv.headers)) self.assertIn("Set-Cookie", rv.headers)
rv = loads(rv.data) rv = loads(rv.data)
assert rv["mode"] == 1 self.assertEqual(rv["mode"], 1)
assert rv["text"] == '<p>Lorem ipsum ...</p>' self.assertEqual(rv["text"], '<p>Lorem ipsum ...</p>')
def textCreateWithNonAsciiText(self): def textCreateWithNonAsciiText(self):
rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Здравствуй, мир!'})) rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Здравствуй, мир!'}))
assert rv.status_code == 201 self.assertEqual(rv.status_code, 201)
assert any(filter(lambda header: header[0] == 'Set-Cookie', rv.headers)) self.assertEqual(any(filter(lambda header: header[0], 'Set-Cookie', rv.headers)))
rv = loads(rv.data) rv = loads(rv.data)
assert rv["mode"] == 1 self.assertEqual(rv["mode"], 1)
assert rv["text"] == '<p>Здравствуй, мир!</p>' self.assertEqual(rv["text"], '<p>Здравствуй, мир!</p>')
def testCreateMultiple(self): def testCreateMultiple(self):
@ -86,9 +90,9 @@ class TestComments(unittest.TestCase):
b = self.post('/new?uri=test', data=json.dumps({'text': '...'})) b = self.post('/new?uri=test', data=json.dumps({'text': '...'}))
c = self.post('/new?uri=test', data=json.dumps({'text': '...'})) c = self.post('/new?uri=test', data=json.dumps({'text': '...'}))
assert loads(a.data)["id"] == 1 self.assertEqual(loads(a.data)["id"], 1)
assert loads(b.data)["id"] == 2 self.assertEqual(loads(b.data)["id"], 2)
assert loads(c.data)["id"] == 3 self.assertEqual(loads(c.data)["id"], 3)
def testCreateAndGetMultiple(self): def testCreateAndGetMultiple(self):
@ -96,22 +100,23 @@ class TestComments(unittest.TestCase):
self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Spam'})) self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Spam'}))
r = self.get('/?uri=%2Fpath%2F') r = self.get('/?uri=%2Fpath%2F')
assert r.status_code == 200 self.assertEqual(r.status_code, 200)
rv = loads(r.data) rv = loads(r.data)
assert len(rv) == 20 self.assertEqual(len(rv), 20)
def testVerifyFields(self):
def testCreateBlank(self):
rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': ''})) rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': ''}))
assert rv.status_code == 400 self.assertEqual(rv.status_code, 400)
rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': "\n\n\n"})) rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': "\n\n\n"}))
assert rv.status_code == 400 self.assertEqual(rv.status_code, 400)
def testGetInvalid(self): def testGetInvalid(self):
assert self.get('/?uri=%2Fpath%2F&id=123').status_code == 404 self.assertEqual(self.get('/?uri=%2Fpath%2F&id=123').status_code, 404)
assert self.get('/?uri=%2Fpath%2Fspam%2F&id=123').status_code == 404 self.assertEqual(self.get('/?uri=%2Fpath%2Fspam%2F&id=123').status_code, 404)
assert self.get('/?uri=?uri=%foo%2F').status_code == 404 self.assertEqual(self.get('/?uri=?uri=%foo%2F').status_code, 404)
def testUpdate(self): def testUpdate(self):
@ -120,21 +125,21 @@ class TestComments(unittest.TestCase):
'text': 'Hello World', 'author': 'me', 'website': 'http://example.com/'})) 'text': 'Hello World', 'author': 'me', 'website': 'http://example.com/'}))
r = self.get('/id/1?plain=1') r = self.get('/id/1?plain=1')
assert r.status_code == 200 self.assertEqual(r.status_code, 200)
rv = loads(r.data) rv = loads(r.data)
assert rv['text'] == 'Hello World' self.assertEqual(rv['text'], 'Hello World')
assert rv['author'] == 'me' self.assertEqual(rv['author'], 'me')
assert rv['website'] == 'http://example.com/' self.assertEqual(rv['website'], 'http://example.com/')
assert 'modified' in rv self.assertIn('modified', rv)
def testDelete(self): def testDelete(self):
self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'}))
r = self.delete('/id/1') r = self.delete('/id/1')
assert r.status_code == 200 self.assertEqual(r.status_code, 200)
assert loads(r.data) == None self.assertEqual(loads(r.data), None)
assert self.get('/id/1').status_code == 404 self.assertEqual(self.get('/id/1').status_code, 404)
def testDeleteWithReference(self): def testDeleteWithReference(self):
@ -143,16 +148,16 @@ class TestComments(unittest.TestCase):
client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'First', 'parent': 1})) client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'First', 'parent': 1}))
r = client.delete('/id/1') r = client.delete('/id/1')
assert r.status_code == 200 self.assertEqual(r.status_code, 200)
assert loads(r.data)['mode'] == 4 self.assertEqual(loads(r.data)['mode'], 4)
assert '/path/' in self.app.db.threads self.assertIn('/path/', self.app.db.threads)
assert self.get('/?uri=%2Fpath%2F&id=1').status_code == 200 self.assertEqual(self.get('/?uri=%2Fpath%2F&id=1').status_code, 200)
assert self.get('/?uri=%2Fpath%2F&id=2').status_code == 200 self.assertEqual(self.get('/?uri=%2Fpath%2F&id=2').status_code, 200)
r = client.delete('/id/2') r = client.delete('/id/2')
assert self.get('/?uri=%2Fpath%2F').status_code == 404 self.assertEqual(self.get('/?uri=%2Fpath%2F').status_code, 404)
assert '/path/' not in self.app.db.threads self.assertNotIn('/path/', self.app.db.threads)
def testDeleteWithMultipleReferences(self): def testDeleteWithMultipleReferences(self):
""" """
@ -174,27 +179,27 @@ class TestComments(unittest.TestCase):
client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': '...'})) client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': '...'}))
client.delete('/id/1') client.delete('/id/1')
assert self.get('/?uri=%2Fpath%2F').status_code == 200 self.assertEqual(self.get('/?uri=%2Fpath%2F').status_code, 200)
client.delete('/id/2') client.delete('/id/2')
assert self.get('/?uri=%2Fpath%2F').status_code == 200 self.assertEqual(self.get('/?uri=%2Fpath%2F').status_code, 200)
client.delete('/id/3') client.delete('/id/3')
assert self.get('/?uri=%2Fpath%2F').status_code == 200 self.assertEqual(self.get('/?uri=%2Fpath%2F').status_code, 200)
client.delete('/id/4') client.delete('/id/4')
assert self.get('/?uri=%2Fpath%2F').status_code == 200 self.assertEqual(self.get('/?uri=%2Fpath%2F').status_code, 200)
client.delete('/id/5') client.delete('/id/5')
assert self.get('/?uri=%2Fpath%2F').status_code == 404 self.assertEqual(self.get('/?uri=%2Fpath%2F').status_code, 404)
def testPathVariations(self): def testPathVariations(self):
paths = ['/sub/path/', '/path.html', '/sub/path.html', 'path', '/'] paths = ['/sub/path/', '/path.html', '/sub/path.html', 'path', '/']
for path in paths: for path in paths:
assert self.post('/new?' + urlencode({'uri': path}), self.assertEqual(self.post('/new?' + urlencode({'uri': path}),
data=json.dumps({'text': '...'})).status_code == 201 data=json.dumps({'text': '...'})).status_code, 201)
for i, path in enumerate(paths): for i, path in enumerate(paths):
assert self.get('/?' + urlencode({'uri': path})).status_code == 200 self.assertEqual(self.get('/?' + urlencode({'uri': path})).status_code, 200)
assert self.get('/id/%i' % (i + 1)).status_code == 200 self.assertEqual(self.get('/id/%i' % (i + 1)).status_code, 200)
def testDeleteAndCreateByDifferentUsersButSamePostId(self): def testDeleteAndCreateByDifferentUsersButSamePostId(self):
@ -205,8 +210,8 @@ class TestComments(unittest.TestCase):
bob = JSONClient(self.app, Response) bob = JSONClient(self.app, Response)
bob.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Bar'})) bob.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Bar'}))
assert mallory.delete('/id/1').status_code == 403 self.assertEqual(mallory.delete('/id/1').status_code, 403)
assert bob.delete('/id/1').status_code == 200 self.assertEqual(bob.delete('/id/1').status_code, 200)
def testHash(self): def testHash(self):
@ -214,65 +219,64 @@ class TestComments(unittest.TestCase):
b = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Bbb"})) b = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Bbb"}))
c = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Ccc", "email": "..."})) c = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Ccc", "email": "..."}))
assert a.status_code == b.status_code == c.status_code == 201
a = loads(a.data) a = loads(a.data)
b = loads(b.data) b = loads(b.data)
c = loads(c.data) c = loads(c.data)
assert isinstance(int(a['hash'], 16), int) self.assertIsInstance(int(a['hash'], 16), int)
assert a['hash'] != '192.168.1.1' self.assertNotEqual(a['hash'], '192.168.1.1')
assert a['hash'] == b['hash'] self.assertEqual(a['hash'], b['hash'])
assert a['hash'] != c['hash'] self.assertNotEqual(a['hash'], c['hash'])
def testVisibleFields(self): def testVisibleFields(self):
rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."}))
assert rv.status_code == 201 self.assertEqual(rv.status_code, 201)
rv = loads(rv.data) rv = loads(rv.data)
for key in comments.API.FIELDS: for key in comments.API.FIELDS:
rv.pop(key) rv.pop(key)
assert not any(rv.keys()) self.assertListEqual(list(rv.keys()), [])
def testCounts(self): def testCounts(self):
assert self.get('/count?uri=%2Fpath%2F').status_code == 404 self.assertEqual(self.get('/count?uri=%2Fpath%2F').status_code, 404)
self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."}))
rv = self.get('/count?uri=%2Fpath%2F') rv = self.get('/count?uri=%2Fpath%2F')
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
assert loads(rv.data) == 1 self.assertEqual(loads(rv.data), 1)
for x in range(3): for x in range(3):
self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."}))
rv = self.get('/count?uri=%2Fpath%2F') rv = self.get('/count?uri=%2Fpath%2F')
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
assert loads(rv.data) == 4 self.assertEqual(loads(rv.data), 4)
for x in range(4): for x in range(4):
self.delete('/id/%i' % (x + 1)) self.delete('/id/%i' % (x + 1))
rv = self.get('/count?uri=%2Fpath%2F') rv = self.get('/count?uri=%2Fpath%2F')
assert rv.status_code == 404 self.assertEqual(rv.status_code, 404)
def testModify(self): def testModify(self):
self.post('/new?uri=test', data=json.dumps({"text": "Tpyo"})) self.post('/new?uri=test', data=json.dumps({"text": "Tpyo"}))
self.put('/id/1', data=json.dumps({"text": "Tyop"})) self.put('/id/1', data=json.dumps({"text": "Tyop"}))
assert loads(self.get('/id/1').data)["text"] == "<p>Tyop</p>" self.assertEqual(loads(self.get('/id/1').data)["text"], "<p>Tyop</p>")
self.put('/id/1', data=json.dumps({"text": "Typo"})) self.put('/id/1', data=json.dumps({"text": "Typo"}))
assert loads(self.get('/id/1').data)["text"] == "<p>Typo</p>" self.assertEqual(loads(self.get('/id/1').data)["text"], "<p>Typo</p>")
def testDeleteCommentRemovesThread(self): def testDeleteCommentRemovesThread(self):
rv = self.client.post('/new?uri=%2F', data=json.dumps({"text": "..."})) rv = self.client.post('/new?uri=%2F', data=json.dumps({"text": "..."}))
assert '/' in self.app.db.threads self.assertIn('/', self.app.db.threads)
self.client.delete('/id/1') self.client.delete('/id/1')
assert '/' not in self.app.db.threads self.assertNotIn('/', self.app.db.threads)
def testCSRF(self): def testCSRF(self):
@ -282,17 +286,17 @@ class TestComments(unittest.TestCase):
self.post('/new?uri=%2F', data=json.dumps({"text": "..."})) self.post('/new?uri=%2F', data=json.dumps({"text": "..."}))
# no header is fine (default for XHR) # no header is fine (default for XHR)
assert self.post('/id/1/dislike', content_type="").status_code == 200 self.assertEqual(self.post('/id/1/dislike', content_type="").status_code, 200)
# x-www-form-urlencoded is definitely not RESTful # x-www-form-urlencoded is definitely not RESTful
assert self.post('/id/1/dislike', content_type=form).status_code == 403 self.assertEqual(self.post('/id/1/dislike', content_type=form).status_code, 403)
assert self.post('/new?uri=%2F', data=json.dumps({"text": "..."}), self.assertEqual(self.post('/new?uri=%2F', data=json.dumps({"text": "..."}),
content_type=form).status_code == 403 content_type=form).status_code, 403)
# just for the record # just for the record
assert self.post('/id/1/dislike', content_type=js).status_code == 200 self.assertEqual(self.post('/id/1/dislike', content_type=js).status_code, 200)
def testCheckIP(self): def testCheckIP(self):
assert self.get('/check-ip').data.decode("utf-8") == '192.168.1.0' self.assertEqual(self.get('/check-ip').data.decode("utf-8"), '192.168.1.0')
class TestModeratedComments(unittest.TestCase): class TestModeratedComments(unittest.TestCase):
@ -317,13 +321,13 @@ class TestModeratedComments(unittest.TestCase):
def testAddComment(self): def testAddComment(self):
rv = self.client.post('/new?uri=test', data=json.dumps({"text": "..."})) rv = self.client.post('/new?uri=test', data=json.dumps({"text": "..."}))
assert rv.status_code == 202 self.assertEqual(rv.status_code, 202)
assert self.client.get('/id/1').status_code == 200 self.assertEqual(self.client.get('/id/1').status_code, 200)
assert self.client.get('/?uri=test').status_code == 404 self.assertEqual(self.client.get('/?uri=test').status_code, 404)
self.app.db.comments.activate(1) self.app.db.comments.activate(1)
assert self.client.get('/?uri=test').status_code == 200 self.assertEqual(self.client.get('/?uri=test').status_code, 200)
class TestPurgeComments(unittest.TestCase): class TestPurgeComments(unittest.TestCase):
@ -346,13 +350,13 @@ class TestPurgeComments(unittest.TestCase):
self.client.post('/new?uri=test', data=json.dumps({"text": "..."})) self.client.post('/new?uri=test', data=json.dumps({"text": "..."}))
self.app.db.comments.activate(1) self.app.db.comments.activate(1)
self.app.db.comments.purge(0) self.app.db.comments.purge(0)
assert self.client.get('/?uri=test').status_code == 200 self.assertEqual(self.client.get('/?uri=test').status_code, 200)
def testPurgeWorks(self): def testPurgeWorks(self):
self.client.post('/new?uri=test', data=json.dumps({"text": "..."})) self.client.post('/new?uri=test', data=json.dumps({"text": "..."}))
self.app.db.comments.purge(0) self.app.db.comments.purge(0)
assert self.client.get('/id/1').status_code == 404 self.assertEqual(self.client.get('/id/1').status_code, 404)
self.client.post('/new?uri=test', data=json.dumps({"text": "..."})) self.client.post('/new?uri=test', data=json.dumps({"text": "..."}))
self.app.db.comments.purge(3600) self.app.db.comments.purge(3600)
assert self.client.get('/id/1').status_code == 200 self.assertEqual(self.client.get('/id/1').status_code, 200)

61
specs/test_cors.py
View File

@ -1,6 +1,11 @@
from __future__ import unicode_literals from __future__ import unicode_literals
try:
import unittest2 as unittest
except ImportError:
import unittest
from werkzeug.test import Client from werkzeug.test import Client
from werkzeug.wrappers import Response from werkzeug.wrappers import Response
@ -13,43 +18,45 @@ def hello_world(environ, start_response):
return ["Hello, World."] return ["Hello, World."]
def test_simple_CORS(): class CORSTest(unittest.TestCase):
app = CORSMiddleware(hello_world, origin=origin([ def test_simple(self):
"https://example.tld/",
"http://example.tld/",
"http://example.tld",
]))
client = Client(app, Response) app = CORSMiddleware(hello_world, origin=origin([
"https://example.tld/",
"http://example.tld/",
"http://example.tld",
]))
rv = client.get("/", headers={"ORIGIN": "https://example.tld"}) client = Client(app, Response)
assert rv.headers["Access-Control-Allow-Origin"] == "https://example.tld" rv = client.get("/", headers={"ORIGIN": "https://example.tld"})
assert rv.headers["Access-Control-Allow-Headers"] == "Origin, Content-Type"
assert rv.headers["Access-Control-Allow-Credentials"] == "true"
assert rv.headers["Access-Control-Allow-Methods"] == "GET, POST, PUT, DELETE"
assert rv.headers["Access-Control-Expose-Headers"] == "X-Set-Cookie"
a = client.get("/", headers={"ORIGIN": "http://example.tld"}) self.assertEqual(rv.headers["Access-Control-Allow-Origin"], "https://example.tld")
assert a.headers["Access-Control-Allow-Origin"] == "http://example.tld" self.assertEqual(rv.headers["Access-Control-Allow-Headers"], "Origin, Content-Type")
self.assertEqual(rv.headers["Access-Control-Allow-Credentials"], "true")
self.assertEqual(rv.headers["Access-Control-Allow-Methods"], "GET, POST, PUT, DELETE")
self.assertEqual(rv.headers["Access-Control-Expose-Headers"], "X-Set-Cookie")
b = client.get("/", headers={"ORIGIN": "http://example.tld"}) a = client.get("/", headers={"ORIGIN": "http://example.tld"})
assert b.headers["Access-Control-Allow-Origin"] == "http://example.tld" self.assertEqual(a.headers["Access-Control-Allow-Origin"], "http://example.tld")
c = client.get("/", headers={"ORIGIN": "http://foo.other"}) b = client.get("/", headers={"ORIGIN": "http://example.tld"})
assert c.headers["Access-Control-Allow-Origin"] == "https://example.tld" self.assertEqual(b.headers["Access-Control-Allow-Origin"], "http://example.tld")
c = client.get("/", headers={"ORIGIN": "http://foo.other"})
self.assertEqual(c.headers["Access-Control-Allow-Origin"], "https://example.tld")
def test_preflight_CORS(): def test_preflight(self):
app = CORSMiddleware(hello_world, origin=origin(["http://example.tld"])) app = CORSMiddleware(hello_world, origin=origin(["http://example.tld"]))
client = Client(app, Response) client = Client(app, Response)
rv = client.open(method="OPTIONS", path="/", headers={"ORIGIN": "http://example.tld"}) rv = client.open(method="OPTIONS", path="/", headers={"ORIGIN": "http://example.tld"})
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
for hdr in ("Origin", "Headers", "Credentials", "Methods"): for hdr in ("Origin", "Headers", "Credentials", "Methods"):
assert "Access-Control-Allow-%s" % hdr in rv.headers self.assertIn("Access-Control-Allow-%s" % hdr, rv.headers)
assert rv.headers["Access-Control-Allow-Origin"] == "http://example.tld" self.assertEqual(rv.headers["Access-Control-Allow-Origin"], "http://example.tld")

33
specs/test_guard.py
View File

@ -1,6 +1,9 @@
# -*- encoding: utf-8 -*- # -*- encoding: utf-8 -*-
import unittest try:
import unittest2 as unittest
except ImportError:
import unittest
import json import json
import tempfile import tempfile
@ -52,16 +55,16 @@ class TestGuard(unittest.TestCase):
for i in range(2): for i in range(2):
rv = bob.post('/new?uri=test', data=self.data) rv = bob.post('/new?uri=test', data=self.data)
assert rv.status_code == 201 self.assertEqual(rv.status_code, 201)
rv = bob.post('/new?uri=test', data=self.data) rv = bob.post('/new?uri=test', data=self.data)
assert rv.status_code == 403 self.assertEqual(rv.status_code, 403)
assert "ratelimit exceeded" in rv.get_data(as_text=True) self.assertIn("ratelimit exceeded", rv.get_data(as_text=True))
alice = self.makeClient("1.2.3.4", 2) alice = self.makeClient("1.2.3.4", 2)
for i in range(2): for i in range(2):
assert alice.post("/new?uri=test", data=self.data).status_code == 201 self.assertEqual(alice.post("/new?uri=test", data=self.data).status_code, 201)
bob.application.db.execute([ bob.application.db.execute([
"UPDATE comments SET", "UPDATE comments SET",
@ -69,7 +72,7 @@ class TestGuard(unittest.TestCase):
"WHERE remote_addr = '127.0.0.0'" "WHERE remote_addr = '127.0.0.0'"
]) ])
assert bob.post("/new?uri=test", data=self.data).status_code == 201 self.assertEqual(bob.post("/new?uri=test", data=self.data).status_code, 201)
def testDirectReply(self): def testDirectReply(self):
@ -78,21 +81,21 @@ class TestGuard(unittest.TestCase):
for url in ("foo", "bar", "baz", "spam"): for url in ("foo", "bar", "baz", "spam"):
for _ in range(3): for _ in range(3):
rv = client.post("/new?uri=%s" % url, data=self.data) rv = client.post("/new?uri=%s" % url, data=self.data)
assert rv.status_code == 201 self.assertEqual(rv.status_code, 201)
for url in ("foo", "bar", "baz", "spam"): for url in ("foo", "bar", "baz", "spam"):
rv = client.post("/new?uri=%s" % url, data=self.data) rv = client.post("/new?uri=%s" % url, data=self.data)
assert rv.status_code == 403 self.assertEqual(rv.status_code, 403)
assert "direct responses to" in rv.get_data(as_text=True) self.assertIn("direct responses to", rv.get_data(as_text=True))
def testSelfReply(self): def testSelfReply(self):
payload = lambda id: json.dumps({"text": "...", "parent": id}) payload = lambda id: json.dumps({"text": "...", "parent": id})
client = self.makeClient("127.0.0.1", self_reply=False) client = self.makeClient("127.0.0.1", self_reply=False)
assert client.post("/new?uri=test", data=self.data).status_code == 201 self.assertEqual(client.post("/new?uri=test", data=self.data).status_code, 201)
assert client.post("/new?uri=test", data=payload(1)).status_code == 403 self.assertEqual(client.post("/new?uri=test", data=payload(1)).status_code, 403)
client.application.db.execute([ client.application.db.execute([
"UPDATE comments SET", "UPDATE comments SET",
@ -100,9 +103,9 @@ class TestGuard(unittest.TestCase):
"WHERE id = 1" "WHERE id = 1"
], (client.application.conf.getint("general", "max-age"), )) ], (client.application.conf.getint("general", "max-age"), ))
assert client.post("/new?uri=test", data=payload(1)).status_code == 201 self.assertEqual(client.post("/new?uri=test", data=payload(1)).status_code, 201)
client = self.makeClient("128.0.0.1", ratelimit=3, self_reply=False) client = self.makeClient("128.0.0.1", ratelimit=3, self_reply=False)
assert client.post("/new?uri=test", data=self.data).status_code == 201 self.assertEqual(client.post("/new?uri=test", data=self.data).status_code, 201)
assert client.post("/new?uri=test", data=payload(1)).status_code == 201 self.assertEqual(client.post("/new?uri=test", data=payload(1)).status_code, 201)
assert client.post("/new?uri=test", data=payload(2)).status_code == 201 self.assertEqual(client.post("/new?uri=test", data=payload(2)).status_code, 201)

38
specs/test_vote.py
View File

@ -1,10 +1,13 @@
from __future__ import unicode_literals from __future__ import unicode_literals
import os
import json import json
import tempfile import tempfile
import unittest
try:
import unittest2 as unittest
except ImportError:
import unittest
from werkzeug.wrappers import Response from werkzeug.wrappers import Response
@ -37,15 +40,16 @@ class TestVote(unittest.TestCase):
def testZeroLikes(self): def testZeroLikes(self):
rv = self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."})) rv = self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."}))
assert loads(rv.data)['likes'] == loads(rv.data)['dislikes'] == 0 self.assertEqual(loads(rv.data)['likes'], 0)
self.assertEqual(loads(rv.data)['dislikes'], 0)
def testSingleLike(self): def testSingleLike(self):
self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."})) self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."}))
rv = self.makeClient("0.0.0.0").post("/id/1/like") rv = self.makeClient("0.0.0.0").post("/id/1/like")
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
assert loads(rv.data)["likes"] == 1 self.assertEqual(loads(rv.data)["likes"], 1)
def testSelfLike(self): def testSelfLike(self):
@ -53,38 +57,38 @@ class TestVote(unittest.TestCase):
bob.post("/new?uri=test", data=json.dumps({"text": "..."})) bob.post("/new?uri=test", data=json.dumps({"text": "..."}))
rv = bob.post('/id/1/like') rv = bob.post('/id/1/like')
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
assert loads(rv.data)["likes"] == 0 self.assertEqual(loads(rv.data)["likes"], 0)
def testMultipleLikes(self): def testMultipleLikes(self):
self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."})) self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."}))
for num in range(15): for num in range(15):
rv = self.makeClient("1.2.%i.0" % num).post('/id/1/like') rv = self.makeClient("1.2.%i.0" % num).post('/id/1/like')
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
assert loads(rv.data)["likes"] == num + 1 self.assertEqual(loads(rv.data)["likes"], num + 1)
def testVoteOnNonexistentComment(self): def testVoteOnNonexistentComment(self):
rv = self.makeClient("1.2.3.4").post('/id/1/like') rv = self.makeClient("1.2.3.4").post('/id/1/like')
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
assert loads(rv.data) == None self.assertEqual(loads(rv.data), None)
def testTooManyLikes(self): def testTooManyLikes(self):
self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."})) self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."}))
for num in range(256): for num in range(256):
rv = self.makeClient("1.2.%i.0" % num).post('/id/1/like') rv = self.makeClient("1.2.%i.0" % num).post('/id/1/like')
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
if num >= 142: if num >= 142:
assert loads(rv.data)["likes"] == 142 self.assertEqual(loads(rv.data)["likes"], 142)
else: else:
assert loads(rv.data)["likes"] == num + 1 self.assertEqual(loads(rv.data)["likes"], num + 1)
def testDislike(self): def testDislike(self):
self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."})) self.makeClient("127.0.0.1").post("/new?uri=test", data=json.dumps({"text": "..."}))
rv = self.makeClient("1.2.3.4").post('/id/1/dislike') rv = self.makeClient("1.2.3.4").post('/id/1/dislike')
assert rv.status_code == 200 self.assertEqual(rv.status_code, 200)
assert loads(rv.data)['likes'] == 0 self.assertEqual(loads(rv.data)['likes'], 0)
assert loads(rv.data)['dislikes'] == 1 self.assertEqual(loads(rv.data)['dislikes'], 1)

1
tox.ini
View File

@ -4,6 +4,7 @@ envlist = py26,py27,py33
deps = deps =
argparse argparse
configparser configparser
unittest2
{[testenv]deps} {[testenv]deps}
[testenv:py27] [testenv:py27]
deps = deps =