So, these days I was working in a project that uses requests to make some http/https calls:
import requests
URL = 'https://us.api.battle.net/wow/auction/data/{}?locale=en_US'
API = 'myapikey'
def request_with_api(url):
apikey = {'apikey': API}
return requests.get(url, params=apikey)
def get_auctions_url(realm):
url = URL.format(realm)
r = request_with_api(url)
if r.status_code == 200:
data = r.json()
data_url = data['files'][0]['url']
return data_url
return None
def get_auctions(realm):
url = get_auctions_url(realm)
if url:
r = request_with_api(url)
if r.status_code == 200:
return r.json()
else:
raise Exception('Error in return code: %s' % r.status_code)
else:
raise Exception('Auction data not found')
if __name__ == '__main__':
auctions = get_auctions('medivh')
print auctions
And as usual, I wanted to have my unit tests, and requests is very tricky, because, you don’t want to keep making requests to the real server, every time you run your unit tests, and here is a couple of reasons:
- I’ll depend of internet to access the server all the time
- The server has a limit of requests that I don’t want to waste testing
- Some servers may block your account if you do too many requests in a small amount of time.
Mocking
So, the easiest way to test would be using mock, and then do something like this:
import unittest
import mock
import wow
from wow import request_with_api
class TestWow(unittest.TestCase):
@mock.patch('wow.request_with_api')
def test_get_auctions_url(self, wow_patch):
wow_patch.return_value.status_code = 200
wow_patch.return_value.json.return_value = {'files': [
{'url': ('http://auction-api-us.worldofwarcraft.com/'
'auction-data')}
]}
data = wow.get_auctions_url('medivh')
wow_patch.assert_called_once()
self.assertEquals(data,
'http://auction-api-us.worldofwarcraft.com/auction-data')
wow_patch.reset_mock()
wow_patch.return_value.status_code = 403
data = wow.get_auctions_url('medivh')
wow_patch.assert_called_once()
self.assertIsNone(data)
if __name__ == '__main__':
unittest.main()
This looks good, all I have to do is set the mock return values, reset the mock, set the values of the status_code, the return of the r.json() value, and all of this inside our tests. Of course, I could create the setUp method, and configure the values there:
import unittest
import mock
import wow
from wow import request_with_api
class TestWow(unittest.TestCase):
def setUp(self):
self.ok_return = ('http://auction-api-us.worldofwarcraft.com/'
'auction-data')
self.json_ok_return = {
'files': [
{
'url': self.ok_return
}
]
}
@mock.patch('wow.request_with_api')
def test_get_auctions_url(self, wow_patch):
wow_patch.return_value.status_code = 200
wow_patch.return_value.json.return_value = self.json_ok_return
data = wow.get_auctions_url('medivh')
wow_patch.assert_called_once()
self.assertEquals(data, self.ok_return)
wow_patch.reset_mock()
wow_patch.return_value.status_code = 403
data = wow.get_auctions_url('medivh')
wow_patch.assert_called_once()
self.assertIsNone(data)
if __name__ == '__main__':
unittest.main()
Now, so far, we are only testing the get_auctions_url method, let’s add the test to get_auctions method, who calls the get_auctions_url method as well:
import unittest
import mock
import wow
class TestWow(unittest.TestCase):
def setUp(self):
self.ok_return = ('http://auction-api-us.worldofwarcraft.com/'
'auction-data')
self.json_ok_return = {
'files': [
{
'url': self.ok_return
}
]
}
self.json_auction_data = {
'content': {
"realms": [
{"name": "Medivh", "slug": "medivh"},
{"name": "Exodar", "slug": "exodar"}
],
"auctions": [
{
"auc": 1283349179, "item": 129158,
"owner": "Toiletcow",
"ownerRealm": "Medivh", "bid": 8360, "buyout": 8800,
"quantity": 1, "timeLeft": "LONG", "rand": 0,
"seed": 0, "context": 0
}
]
}
}
@mock.patch('wow.request_with_api')
def test_get_auctions_url(self, wow_patch):
wow_patch.return_value.status_code = 200
wow_patch.return_value.json.return_value = self.json_ok_return
data = wow.get_auctions_url('medivh')
wow_patch.assert_called_once()
self.assertEquals(data, self.ok_return)
wow_patch.reset_mock()
wow_patch.return_value.status_code = 403
data = wow.get_auctions_url('medivh')
wow_patch.assert_called_once()
self.assertIsNone(data)
@mock.patch('wow.get_auctions_url')
@mock.patch('wow.request_with_api')
def test_get_auctions(self, request_with_api_mock,
get_auctions_url_mock):
get_auctions_url_mock.return_value = None
self.assertRaises(Exception, wow.get_auctions, 'medivh')
get_auctions_url_mock.assert_called_once()
get_auctions_url_mock.reset_mock()
request_with_api_mock.return_value.status_code = 200
request_with_api_mock.return_value.json.return_value = (
self.json_auction_data)
get_auctions_url_mock.return_value = self.ok_return
get_auctions_url_mock.json.return_value = self.json_auction_data
data = wow.get_auctions('medivh')
self.assertDictEqual(data, self.json_auction_data)
if __name__ == '__main__':
unittest.main()
So, now things are starting to get a little bit messy, here we need to mock both wow.get_auctions_url, and wow.request_with_api, and reset the mocks and assert that the mock is being called once. It works, but still, it’as a mess for the next guy who will check this code.
HTTMock
The coolest part of the HTTMock is that it returns a requests object for you, which means you can call other requests method if you need it without the need of mock these methods. In our example, we only mocked the json() and status_code, but imagine if we had to mock the headers, responses, etc. HTTMock do that for you.
In my opinion, HTTMock keeps your test methods more clean:
import unittest
from httmock import urlmatch, HTTMock
import wow
@urlmatch(netloc=r'(.*\.)?us\.api\.battle\.net.*$')
def auctions_url(url, request):
not_found = ('http://auction-api-us.worldofwarcraft.com/'
'auction-data/notfound')
found = 'http://auction-api-us.worldofwarcraft.com/auction-data'
if 'fail' in url.path:
return {'status_code': 403}
return {
'status_code': 200,
'content':
{
'files': [
{'url': not_found if 'notfound' in url.path else found}
]
}
}
class TestAuctions(unittest.TestCase):
def test_get_auctions_url(self):
with HTTMock(auctions_url):
data = wow.get_auctions_url('medivh')
self.assertEquals(data, ('http://auction-api-us.worldofwarcraft.'
'com/auction-data'))
with HTTMock(auctions_url):
data = wow.get_auctions_url('fail')
self.assertIsNone(data)
if __name__ == '__main__':
unittest.main()
As you can see, we can set a method with the @urlmatch decorator and all requests that match that particular regular expression will be handle by this method.
Inside that method we also can set some conditionals as I did to test when we have ‘not found’.
Of course, there are other decorators. You can use, for example the @all_requests decorator
import unittest
from httmock import all_requests, HTTMock
import wow
@all_requests
def auctions_url_req(url, request):
not_found = ('http://auction-api-us.worldofwarcraft.com/'
'auction-data/notfound')
found = 'http://auction-api-us.worldofwarcraft.com/auction-data'
if 'fail' in url.path:
return {'status_code': 403}
return {
'status_code': 200,
'content':
{
'files': [
{'url': not_found if 'notfound' in url.path else found}
]
}
}
class TestAuctions(unittest.TestCase):
def test_get_auctions_url(self):
with HTTMock(auctions_url_req):
data = wow.get_auctions_url('medivh')
self.assertEquals(data, ('http://auction-api-us.worldofwarcraft.'
'com/auction-data'))
with HTTMock(auctions_url_req):
data = wow.get_auctions_url('fail')
self.assertIsNone(data)
if __name__ == '__main__':
unittest.main()
In this case, all the requests you do no matter the URL, will be handled by the auctions_url_req:
import requests
with HTTMock(auctions_url_req):
data = requests.get('https://www.google.com')
print(data.status_code)
print(data.json())
And you get this output:
200
{u'files': [{u'url': u'http://auction-api-us.worldofwarcraft.com/auction-data'}]}
Bottom line
Use or not to use HTTMock is up to you, I believe this can make your tests cleaner, it’s much more easy look to a with HTTMock and say: oh, hey, so, this will return whatever is in the with method, cool!
While using mock only, I have to be like, okay… this object is a mock, and the returned value of this method here is 200, and oh, it’s resetting the mock here, so let’s forget about all of this, and start over with the… well, you get the idea.
And of course, you can use more than one method to handle the requests, as you can see on line 65:
import unittest
from httmock import urlmatch, HTTMock, all_requests
import wow
AUCTION_CONTENT = {
"realms": [
{"name": "Medivh", "slug": "medivh"},
{"name": "Exodar", "slug": "exodar"}
],
"auctions": [
{
"auc": 1283349179, "item": 129158,
"owner": "Toiletcow",
"ownerRealm": "Medivh", "bid": 8360, "buyout": 8800,
"quantity": 1, "timeLeft": "LONG", "rand": 0,
"seed": 0, "context": 0
}
]
}
@urlmatch(netloc=r'(.*\.)?us\.api\.battle\.net.*$')
def auctions_url(url, request):
not_found = ('http://auction-api-us.worldofwarcraft.com/'
'auction-data/notfound')
found = 'http://auction-api-us.worldofwarcraft.com/auction-data'
if 'fail' in url.path:
return {'status_code': 403}
return {
'status_code': 200,
'content':
{
'files': [
{'url': not_found if 'notfound' in url.path else found}
]
}
}
@urlmatch(path=r'^\/auction\-data.*$')
def auctions(url, request):
if 'notfound' in url.path:
return {'status_code': 404}
return {'status_code': 200,
'content': AUCTION_CONTENT}
class TestAuctions(unittest.TestCase):
def test_get_auctions_url(self):
with HTTMock(auctions_url_req):
data = wow.get_auctions_url('medivh')
self.assertEquals(data, ('http://auction-api-us.worldofwarcraft.'
'com/auction-data'))
with HTTMock(auctions_url_req):
data = wow.get_auctions_url('fail')
self.assertIsNone(data)
def test_get_auctions(self):
with HTTMock(auctions, auctions_url):
data = wow.get_auctions('medivh')
self.assertDictEqual(data, AUCTION_CONTENT)
with HTTMock(auctions, auctions_url):
self.assertRaises(Exception, wow.get_auctions, 'notfound')
if __name__ == '__main__':
unittest.main()
import requests
And that’s it! Now you have two choices to test your python code that uses requests.