def test_onerror_onsuccess_returning_false(self, mock_urlopen):
"""Tests onerror onsuccess returning False, i.e. onsuccess must be called once"""
data = ['none', '', 'google', ''] # supply an empty string otherwise urllib.read does not stop
a = mock.Mock()
a.read.side_effect = data
mock_urlopen.return_value = a
self.onsuccess_return_value = self.onerror_return_value = False
# self.urls has a valid url (which should execute onsuccess) and an invalid one
# which should execute onerror)
read_async(self.urls, self.onsuccess, self.onerror)
assert len(self.successes) == 1 # or alternatively:
assert self.onsuccess.call_count == 1
def test_mocking_urlread(self, mock_urlopen):
"""Tests onsuccess. WE mock urllib2urlopen.read to return user defined strings"""
data = ['none', '', 'google', ''] # supply an empty string otherwise urllib.read does not stop
a = mock.Mock()
a.read.side_effect = data # returns each item in list
mock_urlopen.return_value = a
# self.urls has a valid url (which should execute onsuccess) and an invalid one
# which should execute onerror)
read_async(self.urls, self.onsuccess, self.onerror)
assert len(self.successes) == 2
assert sorted(data) == ['', ''] + sorted(self.successes) # sort them as the order might differ
assert a.read.call_count == len(data)
def test_urlerrors(self, mock_urlopen):
"""Tests onerror. WE mock urllib2urlopen.read to raise an excpected Exception"""
data = ['none', '', 'google', ''] # supply an empty string otherwise urllib.read does not stop
a = mock.Mock()
def _(*a, **v):
raise urllib2.URLError("")
a.read.side_effect = urllib2.URLError("") # raises it
mock_urlopen.return_value = a
# self.urls has a valid url (which should execute onsuccess) and an invalid one
# which should execute onerror)
read_async(self.urls, self.onsuccess, self.onerror)
assert len(self.errors) == 2
assert a.read.call_count == len(self.urls)
def read_async(self, *a, **v):
for obj, result, exc, url in read_async(*a, **v):
assert _ismainthread()
self.progress += 1
if exc:
self.errors.append(exc)
else:
self.successes.append(result)
def test_onerror_onsuccess_returning_false2(self, mock_urlopen):
"""Tests onerror onsuccess returning False, i.e. the they must be called N times, where
N < len(self.urls). WE mock urllib2urlopen.read with a time to wait in order to be sure
that urllib2urlopen.read is also called LESS times than len(self.urls)"""
# I want to test the above, PLUS that urllib2.urlopen.read is not called the total
# amount of time. For that, let's the working thread make some work, otherwise we do not
# see the difference as all wrkers have finished before calling the first 'onsuccess'
# increase the number of url. Doesnt matter their names, out an int:
urls = [str(i) for i in xrange(10)]
# we cannot set assert urlib.read.call_count < expected_urllib_read_call_count
# BECAUSE it might be equal (if all read are executed before first call to onsuccess)
# On the other hand, testing that urlib.read.call_count <= expected_urllib_read_call_count
# returns True also if they are equal, which does not assures me the onsuccess function
# return value + threading works as expected. So we do some heuristic: we set a combination
# of urls each and urls lengths. We assert that for *at least one* holds:
# urlib.read.call_count < expected_urllib_read_call_count
how_many_one_strictly_lower_than = 0
for blocksize, reads_per_url in product([1, 1024], [1, 10, 100]):
# needs this to rest:
self.setUp()
# set the expected times we weill call urllib2.read:
expected_urllib_read_call_count = len(urls) * reads_per_url
# build return values which satisfy: for each url, read must be called reads_per_url
# times
data = len(urls) * (['x' * blocksize] * (reads_per_url-1) + ['']) # supply an empty string otherwise urllib.read does not stop
urllib2_urlopen_read = mock.Mock()
urllib2_urlopen_read.read.side_effect = data # _read
mock_urlopen.return_value = urllib2_urlopen_read
self.onsuccess_return_value = self.onerror_return_value = False
# self.urls has a valid url (which should execute onsuccess) and an invalid one
# which should execute onerror)
read_async(urls, self.onsuccess, self.onerror, blocksize=blocksize)
assert self.onsuccess.call_count == 1
assert urllib2_urlopen_read.read.call_count <= expected_urllib_read_call_count
if urllib2_urlopen_read.read.call_count < expected_urllib_read_call_count:
how_many_one_strictly_lower_than +=1
assert how_many_one_strictly_lower_than > 0
def read_async_raise_exc_in_called_func(self, *a, **v):
"""it is easy to check what happens if an unknown exception is raised from urllib: just mock it
but what about an exception raised in the caller body, if urlread is ok? Check it here
"""
for obj, result, exc, url in read_async(*a, **v):
assert _ismainthread()
raise KeyboardInterrupt()
self.progress += 1
if exc:
self.errors.append(exc)
else:
self.successes.append(result)
