class VerifyTest(TestCase):
def setUp(self):
self.server = StubServer(8998)
def test_verify_checks_all_expectations(self):
satisfied_expectation = self._MockExpectation(True)
unsatisfied_expectation = self._MockExpectation(False)
self.server._expectations = [
satisfied_expectation,
unsatisfied_expectation,
satisfied_expectation
]
self.assertRaises(Exception, self.server.verify)
def test_verify_clears_all_expectations(self):
satisfied_expectation = self._MockExpectation(True)
self.server._expectations = [
satisfied_expectation,
satisfied_expectation,
satisfied_expectation
]
self.server.verify()
self.assertEqual([], self.server._expectations)
class _MockExpectation(object):
def __init__(self, satisfied):
self.satisfied = satisfied
def setUp(self):
self.port = self._get_free_port()
self.path, fn = split(abspath(__file__))
self.server = StubServer(self.port)
self.server.run()
# Testing urls are fictional, but it does not really matter
self.s = NajdiSiSms(username="******", password="******")
self.s.logout_url = "http://localhost:%d/logout" % self.port
self.s.login_url = "http://localhost:%d/login" % self.port
self.s.session_url = "http://localhost:%d/session" % self.port
self.s.home_url = "http://localhost:%d/" % self.port
self.s.send_url = "http://localhost:%d" \
"/{session}/{prefix}/{number}/{data}" %self.port
def setUp(self):
self.port = self._get_free_port()
self.path, fn = split(abspath(__file__))
self.server = StubServer(self.port)
self.server.run()
# Testing urls are fictional, but it does not really matter
self.s = NajdiSiSms(username= "******", password= "******")
self.s.logout_url = "http://localhost:%d/logout" %self.port
self.s.login_url = "http://localhost:%d/login" %self.port
self.s.session_url = "http://localhost:%d/session" %self.port
self.s.home_url = "http://localhost:%d/" %self.port
self.s.send_url = "http://localhost:%d" \
"/{session}/{prefix}/{number}/{data}" %self.port
def setUp(self):
self.server = StubServer(8998)
class WebTest(TestCase):
def setUp(self):
self.server = StubServer(8998)
self.server.run()
def tearDown(self):
self.server.stop()
self.server.verify() # this is redundant because stop includes verify
def _make_request(self, url, method="GET", payload="", headers={}):
self.opener = OpenerDirector()
self.opener.add_handler(HTTPHandler())
request = Request(url, headers=headers, data=payload.encode('utf-8'))
request.get_method = lambda: method
response = self.opener.open(request)
response_code = getattr(response, 'code', -1)
return (response, response_code)
def test_get_with_file_call(self):
with open('data.txt', 'w') as f:
f.write("test file")
self.server.expect(method="GET", url="/address/\d+$").and_return(mime_type="text/xml", file_content="./data.txt")
response, response_code = self._make_request("http://localhost:8998/address/25", method="GET")
with open("./data.txt", "r") as f:
expected = f.read().encode('utf-8')
try:
self.assertEqual(expected, response.read())
finally:
response.close()
def test_put_with_capture(self):
capture = {}
self.server.expect(method="PUT", url="/address/\d+$", data_capture=capture).and_return(reply_code=201)
f, reply_code = self._make_request("http://localhost:8998/address/45", method="PUT", payload=str({"hello": "world", "hi": "mum"}))
try:
self.assertEqual(b"", f.read())
captured = eval(capture["body"])
self.assertEqual("world", captured["hello"])
self.assertEqual("mum", captured["hi"])
self.assertEqual(201, reply_code)
finally:
f.close()
def test_post_with_data_and_no_body_response(self):
self.server.expect(method="POST", url="address/\d+/inhabitant", data='<inhabitant name="Chris"/>').and_return(reply_code=204)
f, reply_code = self._make_request("http://localhost:8998/address/45/inhabitant", method="POST", payload='<inhabitant name="Chris"/>')
self.assertEqual(204, reply_code)
def test_multiple_expectations_identifies_correct_unmatched_request(self):
self.server.expect(method="POST", url="address/\d+/inhabitant", data='Twas brillig and the slithy toves').and_return(reply_code=204)
f, reply_code = self._make_request("http://localhost:8998/address/45/inhabitant", method="POST", payload='Twas brillig and the slithy toves')
self.assertEqual(204, reply_code)
self.server.expect(method="GET", url="/monitor/server_status$").and_return(content="Four score and seven years ago", mime_type="text/html")
try:
self.server.stop()
except Exception as e:
self.assertEqual(-1, str(e).find('brillig'), str(e))
def test_get_with_data(self):
self.server.expect(method="GET", url="/monitor/server_status$").and_return(content="<html><body>Server is up</body></html>", mime_type="text/html")
f, reply_code = self._make_request("http://localhost:8998/monitor/server_status", method="GET")
try:
self.assertTrue(b"Server is up" in f.read())
self.assertEqual(200, reply_code)
finally:
f.close()
def test_get_from_root(self):
self.server.expect(method="GET", url="/$").and_return(content="<html><body>Server is up</body></html>", mime_type="text/html")
f, reply_code = self._make_request("http://localhost:8998/", method="GET")
try:
self.assertTrue(b"Server is up" in f.read())
self.assertEqual(200, reply_code)
finally:
f.close()
def test_put_when_post_expected(self):
# set expectations
self.server.expect(method="POST", url="address/\d+/inhabitant", data='<inhabitant name="Chris"/>').and_return(
reply_code=204)
# try a different method
f, reply_code = self._make_request("http://localhost:8998/address/45/inhabitant", method="PUT",
payload='<inhabitant name="Chris"/>')
# Validate the response
self.assertEqual("Method not allowed", f.msg)
self.assertEqual(405, reply_code)
self.assertTrue(f.read().startswith(b"Method PUT not allowed."))
# And we have an unmet expectation which needs to mention the POST that didn't happen
try:
self.server.stop()
except Exception as e:
self.assertTrue(str(e).find("POST") > 0, str(e))
def test_unexpected_get(self):
f, reply_code = self._make_request("http://localhost:8998/address/45/inhabitant", method="GET")
self.assertEqual(404, reply_code)
self.server.stop()
def test_repeated_get(self):
self.server.expect(method="GET", url="counter$").and_return(content="1")
self.server.expect(method="GET", url="counter$").and_return(content="2")
self.server.expect(method="GET", url="counter$").and_return(content="3")
for i in range(1, 4):
f, reply_code = self._make_request("http://localhost:8998/counter", method="GET")
self.assertEqual(200, reply_code)
self.assertEqual(str(i).encode('utf-8'), f.read())
def test_extra_get(self):
self.server.expect(method="GET", url="counter$").and_return(content="1")
f, reply_code = self._make_request("http://localhost:8998/counter", method="GET")
self.assertEqual(200, reply_code)
self.assertEqual(b"1", f.read())
f, reply_code = self._make_request("http://localhost:8998/counter", method="GET")
self.assertEqual(400, reply_code)
self.assertEqual("Expectations exhausted",f.msg)
self.assertTrue(f.read().startswith(b"Expectations at this URL have already been satisfied.\n"))
class functional_tests(TestCase):
"""
We emulate webserver to perform real testing, because mocking mechanize is
not a way to go.
"""
def _get_free_port(self):
"""
Gets random free port
:returns: Random free port
:rtype: int
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('', 0))
port = sock.getsockname()[1]
sock.close()
return port
def setUp(self):
self.port = self._get_free_port()
self.path, fn = split(abspath(__file__))
self.server = StubServer(self.port)
self.server.run()
# Testing urls are fictional, but it does not really matter
self.s = NajdiSiSms(username="******", password="******")
self.s.logout_url = "http://localhost:%d/logout" % self.port
self.s.login_url = "http://localhost:%d/login" % self.port
self.s.session_url = "http://localhost:%d/session" % self.port
self.s.home_url = "http://localhost:%d/" % self.port
self.s.send_url = "http://localhost:%d" \
"/{session}/{prefix}/{number}/{data}" %self.port
def tearDown(self):
self.server.stop()
def test_login(self):
capture = {}
self.server.expect(method="GET", url="/logout").and_return()
self.server.expect(method="GET", url="/login").and_return(
file_content=join(self.path, "najdisi_login.html"))
self.server.expect(
method="POST",
url="/j_spring_security_check",
data_capture=capture,
).and_return(reply_code=203)
self.server.expect(method="GET", url="/session").and_return(
file_content=join(self.path, "najdisi_loggedin.html"))
self.s._login()
self.assertEqual(
capture["body"],
urlencode([('j_username', 'test'), ('j_password', 'test')]),
"posted data incorrect")
self.assertEqual(self.s._session, '1361468289330')
def test_login_errors(self):
# Test for non incorrect login form name
self.server.expect(method="GET", url="/logout").and_return()
self.server.expect(method="GET", url="/login").and_return(
content="<html><body><form name='notfound'></body></html>")
with self.assertRaisesRegexp(ResponseException,
"Error extracting login form"):
self.s._login()
# Test for correct form name, but nonexisting fields
self.server.expect(method="GET", url="/logout").and_return()
self.server.expect(method="GET", url="/login").and_return(
content="<html><body><form name='lgn'></body></html>")
with self.assertRaisesRegexp(ResponseException,
"Error getting username and password"):
self.s._login()
# Test for unsucessfull login, session id
self.server.expect(method="GET", url="/logout").and_return()
self.server.expect(method="GET", url="/login").and_return(
file_content=join(self.path, "najdisi_login.html"))
self.server.expect(
method="POST",
url="/j_spring_security_check").and_return(reply_code=203)
self.server.expect(method="GET", url="/session").and_return(
file_content=join(self.path, "najdisi_home.html"))
with self.assertRaisesRegexp(ResponseException,
"Error getting session id"):
self.s._login()
def test_send_sms(self):
self.server.expect(
method="GET", url="/1361468289330/41/441325/test").and_return(
mime_type="text/json",
content="{ \"msg_left\" : \"10\", \"msg_cnt\" : \"10\" }")
self.s._send_sms("1361468289330", "41", "441325", "test")
self.assertEqual(self.s.balance, 10)
def test_send_sms_error(self):
self.server.expect(
method="GET",
url="/1361468289330/41/441325/test").and_return(reply_code=404)
with self.assertRaisesRegexp(CommunicationException,
"Error sending sms"):
self.s._send_sms("1361468289330", "41", "441325", "test")
self.server.expect(method="GET",
url="/1361468289330/41/441325/test").and_return(
mime_type="text/json", content="error")
with self.assertRaisesRegexp(ResponseException,
"Error parsing response"):
self.s._send_sms("1361468289330", "41", "441325", "test")
class functional_tests(TestCase):
"""
We emulate webserver to perform real testing, because mocking mechanize is
not a way to go.
"""
def _get_free_port(self):
"""
Gets random free port
:returns: Random free port
:rtype: int
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('', 0))
port = sock.getsockname()[1]
sock.close()
return port
def setUp(self):
self.port = self._get_free_port()
self.path, fn = split(abspath(__file__))
self.server = StubServer(self.port)
self.server.run()
# Testing urls are fictional, but it does not really matter
self.s = NajdiSiSms(username= "******", password= "******")
self.s.logout_url = "http://localhost:%d/logout" %self.port
self.s.login_url = "http://localhost:%d/login" %self.port
self.s.session_url = "http://localhost:%d/session" %self.port
self.s.home_url = "http://localhost:%d/" %self.port
self.s.send_url = "http://localhost:%d" \
"/{session}/{prefix}/{number}/{data}" %self.port
def tearDown(self):
self.server.stop()
def test_login(self):
capture= {}
self.server.expect(method = "GET", url = "/logout").and_return()
self.server.expect(method = "GET", url = "/login").and_return(
file_content = join(self.path, "najdisi_login.html")
)
self.server.expect(method="POST", url="/j_spring_security_check",
data_capture=capture,
).and_return(reply_code=203)
self.server.expect(method="GET", url = "/session").and_return(
file_content=join(self.path,"najdisi_loggedin.html")
)
self.s._login()
self.assertEqual(capture["body"],
urlencode([('j_username', 'test'), ('j_password', 'test')]),
"posted data incorrect")
self.assertEqual(self.s._session, '1361468289330')
def test_login_errors(self):
# Test for non incorrect login form name
self.server.expect(method = "GET", url = "/logout").and_return()
self.server.expect(method="GET", url="/login").and_return(
content="<html><body><form name='notfound'></body></html>"
)
with self.assertRaisesRegexp(ResponseException, "Error extracting login form"):
self.s._login()
# Test for correct form name, but nonexisting fields
self.server.expect(method = "GET", url = "/logout").and_return()
self.server.expect(method="GET", url="/login").and_return(
content="<html><body><form name='lgn'></body></html>"
)
with self.assertRaisesRegexp(ResponseException, "Error getting username and password"):
self.s._login()
# Test for unsucessfull login, session id
self.server.expect(method = "GET", url = "/logout").and_return()
self.server.expect(method="GET", url="/login").and_return(
file_content=join(self.path,"najdisi_login.html")
)
self.server.expect(method="POST", url="/j_spring_security_check"
).and_return(reply_code=203)
self.server.expect(method="GET", url="/session").and_return(
file_content=join(self.path,"najdisi_home.html")
)
with self.assertRaisesRegexp(ResponseException, "Error getting session id"):
self.s._login()
def test_send_sms(self):
self.server.expect(method = "GET", url="/1361468289330/41/441325/test").and_return(
mime_type="text/json",
content="{ \"msg_left\" : \"10\", \"msg_cnt\" : \"10\" }"
)
self.s._send_sms("1361468289330", "41", "441325", "test")
self.assertEqual(self.s.balance, 10)
def test_send_sms_error(self):
self.server.expect(method = "GET", url="/1361468289330/41/441325/test").and_return(
reply_code=404)
with self.assertRaisesRegexp(CommunicationException, "Error sending sms"):
self.s._send_sms("1361468289330", "41", "441325", "test")
self.server.expect(method = "GET", url="/1361468289330/41/441325/test").and_return(
mime_type="text/json",
content="error"
)
with self.assertRaisesRegexp(ResponseException, "Error parsing response"):
self.s._send_sms("1361468289330", "41", "441325", "test")
