def _fake_popen( self, stdout, stderr, sleeptime ):
def wait_stdout( self ):
import time
for line in stdout.splitlines():
time.sleep(sleeptime)
yield line
def wait_stderr( self ):
import time
for line in stderr.splitlines():
time.sleep(sleeptime)
yield line
m = Mock(spec=subprocess.Popen)
sout = Mock()
sout.read = stdout
sout.__iter__ = wait_stdout
serr = Mock()
serr.read = stderr
serr.__iter__ = wait_stderr
m.return_value.stdout = sout
m.return_value.stderr = serr
return m
def default_execute_query_se(query, arraysize):
if STARTOF_MINMAX_QUERY in query:
mock_query_results_config = {'get_col_index.return_value': 1}
mock_query_results = Mock(**mock_query_results_config)
mock_query_results.__iter__ = Mock(return_value=iter([[1, 2]]))
elif "FROM v$logmnr_contents" in query:
mock_row = [1, 2, 3, 4, 5, 6, 7, 8, 9]
mock_query_results_config = {
'get_col_index.return_value': 1,
'fetchone.return_value': mock_row
}
mock_query_results = Mock(**mock_query_results_config)
mock_query_results.__iter__ = Mock(return_value=iter([mock_row]))
elif "WHERE DICTIONARY_BEGIN = 'YES'" in query:
redolog_name = 'my_redolog_name'
mock_row = [redolog_name]
mock_query_results_config = {
'get_col_index.return_value': 0,
'fetchone.return_value': redolog_name
}
mock_query_results = Mock(**mock_query_results_config)
mock_query_results.__iter__ = Mock(return_value=iter([mock_row]))
else:
mock_query_results_config = {
'fetchall.return_value': [('schema', 'table')]
}
mock_query_results = Mock(**mock_query_results_config)
mock_query_results.__iter__ = Mock(return_value=iter([]))
return mock_query_results
def _fake_popen(self, stdout, stderr, sleeptime):
def wait_stdout(self):
import time
for line in stdout.splitlines():
time.sleep(sleeptime)
yield line
def wait_stderr(self):
import time
for line in stderr.splitlines():
time.sleep(sleeptime)
yield line
m = Mock(spec=subprocess.Popen)
sout = Mock()
sout.read = stdout
sout.__iter__ = wait_stdout
serr = Mock()
serr.read = stderr
serr.__iter__ = wait_stderr
m.return_value.stdout = sout
m.return_value.stderr = serr
return m
def test_step_status_is_collected_and_reported(self, format_summary):
feature = Mock()
scenario = Mock()
steps = [Mock(), Mock(), Mock(), Mock(), Mock()]
steps[0].status = 'failed'
steps[0].__iter__ = Mock(return_value=iter([]))
steps[1].status = 'undefined'
steps[1].__iter__ = Mock(return_value=iter([]))
steps[2].status = 'passed'
steps[2].__iter__ = Mock(return_value=iter([]))
steps[3].status = 'passed'
steps[3].__iter__ = Mock(return_value=iter([]))
steps[4].status = None
steps[4].__iter__ = Mock(return_value=iter([]))
feature.status = 'failed'
feature.duration = 12.3
feature.__iter__ = Mock(return_value=iter([scenario]))
scenario.status = 'failed'
scenario.__iter__ = Mock(return_value=iter(steps))
config = Mock()
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
'passed': 2,
'failed': 1,
'skipped': 1,
'untested': 0,
'undefined': 1,
}
eq_(format_summary.call_args_list[2][0], ('step', expected))
def testMagicMethodsIsolatedBetweenMocks(self):
mock1 = Mock()
mock2 = Mock()
mock1.__iter__ = Mock(return_value=iter([]))
self.assertEqual(list(mock1), [])
self.assertRaises(TypeError, lambda: list(mock2))
def test_scenario_status_is_collected_and_reported(self, format_summary,
stderr):
# pylint: disable=W0621
# W0621 Redefining name ... from outer scope (format_summary)
feature = Mock()
scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
scenarios[0].status = 'failed'
scenarios[0].__iter__ = Mock(return_value=iter([]))
scenarios[1].status = 'failed'
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = 'skipped'
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = 'passed'
scenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[4].status = None
scenarios[4].__iter__ = Mock(return_value=iter([]))
feature.status = 'failed'
feature.duration = 12.3
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
'passed': 1,
'failed': 2,
'skipped': 2,
'untested': 0,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_scenario_status_is_collected_and_reported(self, format_summary,
stdout):
feature = Mock()
scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
scenarios[0].status = Status.failed
scenarios[0].__iter__ = Mock(return_value=iter([]))
scenarios[1].status = Status.failed
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = Status.skipped
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = Status.passed
scenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[4].status = Status.untested
scenarios[4].__iter__ = Mock(return_value=iter([]))
feature.status = Status.failed
feature.duration = 12.3
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
sys.stdout.encoding = "UTF-8"
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
Status.passed.name: 1,
Status.failed.name: 2,
Status.skipped.name: 1,
Status.untested.name: 1,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_checkout_deliveries_with_shipping_method(monkeypatch):
shipping_cost = 5
items_cost = 5
partition = Mock(
is_shipping_required=MagicMock(return_value=True),
get_total=Mock(return_value=Price(items_cost, currency=settings.DEFAULT_CURRENCY)),
get_price_per_item=Mock(return_value=Price(items_cost, currency=settings.DEFAULT_CURRENCY)))
def f():
yield partition
partition.__iter__ = Mock(return_value=f())
cart = Mock(partition=Mock(return_value=[partition]),
currency=settings.DEFAULT_CURRENCY)
shipping_method_mock = Mock(get_total=Mock(return_value=Price(shipping_cost, currency=settings.DEFAULT_CURRENCY)))
monkeypatch.setattr(Checkout, 'shipping_method', shipping_method_mock)
checkout = Checkout(
cart, AnonymousUser(), 'tracking_code')
deliveries = list(checkout.deliveries)
assert deliveries[0][1] == Price(shipping_cost, currency=settings.DEFAULT_CURRENCY)
assert deliveries[0][2] == Price(items_cost + shipping_cost, currency=settings.DEFAULT_CURRENCY)
assert deliveries[0][0][0][0] == partition
def test_scenario_status_is_collected_and_reported(self, format_summary,
stdout):
feature = Mock()
scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
scenarios[0].status = 'failed'
scenarios[0].__iter__ = Mock(return_value=iter([]))
scenarios[1].status = 'failed'
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = 'skipped'
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = 'passed'
scenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[4].status = None
scenarios[4].__iter__ = Mock(return_value=iter([]))
feature.status = 'failed'
feature.duration = 12.3
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
'passed': 1,
'failed': 2,
'skipped': 2,
'untested': 0,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def testMagicMethodsIsolatedBetweenMocks(self):
mock1 = Mock()
mock2 = Mock()
mock1.__iter__ = Mock(return_value=iter([]))
self.assertEqual(list(mock1), [])
self.assertRaises(TypeError, lambda: list(mock2))
def test_magic_methods_isolated_between_mocks(self):
mock1 = Mock()
mock2 = Mock()
mock1.__iter__ = Mock(return_value=iter([]))
self.assertEqual(list(mock1), [])
self.assertRaises(TypeError, lambda: list(mock2))
def test_if_pkg_candidate_is_unavailable_then_pkg_is_not_considered(self):
origin = Mock()
origin.origin = 'allowed-origin'
pkg = Mock()
pkg.name = 'findutils'
pkg.is_upgradable = False
pkg.is_installed = True
pkg.installed = Mock()
pkg.installed.policy_priority = -1
pkg.installed.origins = [origin]
pkg.installed.version = '1:0.1'
pkg.candidate = None
pkg.versions = [pkg.installed]
cache = Mock()
cache.__iter__ = Mock(return_value=iter([pkg]))
options = Mock()
pkgs_to_upgrade, pkgs_kept_back = \
calculate_upgradable_pkgs(
cache, options, ['o=allowed-origin'],
['findutils'], [])
self.assertListEqual([], pkgs_to_upgrade)
self.assertEqual(0, len(pkgs_kept_back))
def testMagicMethodsAndSpecSet(self):
class Iterable(object):
def __iter__(self):
pass
mock = Mock(spec_set=Iterable)
self.assertRaises(AttributeError, lambda: mock.__iter__)
mock.__iter__ = Mock(return_value=iter([]))
self.assertEqual(list(mock), [])
class NonIterable(object):
pass
mock = Mock(spec_set=NonIterable)
self.assertRaises(AttributeError, lambda: mock.__iter__)
def set_int():
mock.__int__ = Mock(return_value=iter([]))
self.assertRaises(AttributeError, set_int)
mock = MagicMock(spec_set=Iterable)
self.assertEqual(list(mock), [])
self.assertRaises(AttributeError, set_int)
def test_scenario_status_is_collected_and_reported(self, format_summary,
stdout):
feature = Mock()
scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
scenarios[0].status = Status.failed
scenarios[0].__iter__ = Mock(return_value=iter([]))
scenarios[1].status = Status.failed
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = Status.skipped
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = Status.passed
scenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[4].status = Status.untested
scenarios[4].__iter__ = Mock(return_value=iter([]))
feature.status = Status.failed
feature.duration = 12.3
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
Status.passed.name: 1,
Status.failed.name: 2,
Status.skipped.name: 1,
Status.untested.name: 1,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_magic_methods_isolated_between_mocks(self):
mock1 = Mock()
mock2 = Mock()
mock1.__iter__ = Mock(return_value=iter([]))
self.assertEqual(list(mock1), [])
self.assertRaises(TypeError, lambda: list(mock2))
def test_checkout_deliveries_with_shipping_method(monkeypatch):
shipping_cost = 5
items_cost = 5
partition = Mock(
is_shipping_required=MagicMock(return_value=True),
get_total=Mock(return_value=Price(items_cost, currency=settings.DEFAULT_CURRENCY)),
get_price_per_item=Mock(return_value=Price(items_cost, currency=settings.DEFAULT_CURRENCY)))
def f():
yield partition
partition.__iter__ = Mock(return_value=f())
cart = Mock(partition=Mock(return_value=[partition]),
currency=settings.DEFAULT_CURRENCY)
shipping_method_mock = Mock(get_total=Mock(return_value=Price(shipping_cost, currency=settings.DEFAULT_CURRENCY)))
monkeypatch.setattr(Checkout, 'shipping_method', shipping_method_mock)
checkout = Checkout(
cart, AnonymousUser(), 'tracking_code')
deliveries = list(checkout.deliveries)
assert deliveries[0][1] == Price(shipping_cost, currency=settings.DEFAULT_CURRENCY)
assert deliveries[0][2] == Price(items_cost + shipping_cost, currency=settings.DEFAULT_CURRENCY)
assert deliveries[0][0][0][0] == partition
def test_catter():
fs = Filesystem(DB(':memory:'))
fs.root().add_file('zeroes', [test_asset_ids], 130)
asset = Mock()
asset.__enter__ = Mock(return_value=asset)
asset.__exit__ = Mock(return_value=False)
asset.status = Mock(return_value=proto.AssetStatus(size=1024 * 1024, status=proto.SUCCESS))
asset.__iter__ = Mock(return_value=('\x00' * (128 * 1024) for _ in range(8)))
bithorde = Mock()
bithorde.open = Mock(return_value=asset)
cat = Cat(fs, bithorde)
sha = sha1()
for chunk in cat(P('zeroes')):
sha.update(chunk)
assert_equals(sha.hexdigest(), '3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3')
with assert_raises(FNotFound):
for chunk in cat(P('NON-EXISTING')):
pass
asset.status = Mock(return_value=proto.AssetStatus(status=proto.NOTFOUND))
with assert_raises(NotFoundError):
for chunk in cat(P('zeroes')):
pass
def test_if_origin_does_not_match_then_blacklist_is_not_checked(self):
origin = Mock()
origin.origin = "some-other-origin"
pkg = Mock()
pkg.name = "postgresql"
pkg.is_upgradable = True
pkg.candidate = Mock()
pkg.candidate.policy_priority = 500
pkg.candidate.origins = [origin]
pkg.versions = [pkg.candidate]
cache = Mock()
cache.__iter__ = Mock(return_value=iter([pkg]))
options = Mock()
pkgs_to_upgrade, pkgs_kept_back = \
calculate_upgradable_pkgs(cache,
options,
["o=allowed-origin"],
["postgresql"],
[])
self.assertListEqual([], pkgs_to_upgrade)
self.assertEqual(0, len(pkgs_kept_back))
def test_scenario_status_is_collected_and_reported(self, format_summary,
stdout):
feature = Mock()
scenarios = [Mock(), Mock(), Mock(), Mock(), Mock()]
scenarios[0].status = 'failed'
scenarios[0].__iter__ = Mock(return_value=iter([]))
scenarios[1].status = 'failed'
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = 'skipped'
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = 'passed'
scenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[4].status = None
scenarios[4].__iter__ = Mock(return_value=iter([]))
feature.status = 'failed'
feature.duration = 12.3
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
config.order = ('defined', None)
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
'passed': 1,
'failed': 2,
'skipped': 2,
'untested': 0,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_bound_methods(self):
m = Mock()
# XXXX should this be an expected failure instead?
# this seems like it should work, but is hard to do without introducing
# other api inconsistencies. Failure message could be better though.
m.__iter__ = [3].__iter__
self.assertRaises(TypeError, iter, m)
def test_bound_methods(self):
m = Mock()
# XXXX should this be an expected failure instead?
# this seems like it should work, but is hard to do without introducing
# other api inconsistencies. Failure message could be better though.
m.__iter__ = [3].__iter__
self.assertRaises(TypeError, iter, m)
def test_set_admin(self):
user = "******"
MockAdmin = Mock()
MockAdmin.__iter__ = Mock(return_value=iter([user]))
mock_set_secure_cookie = Mock()
with patch.object(settings, 'ADMINISTRATORS', MockAdmin):
with patch.object(self.auth_handler, 'set_secure_cookie', mock_set_secure_cookie):
self.auth_handler.set_admin(user)
mock_set_secure_cookie.assert_called_once_with('admin', 'true')
def test_set_admin_not_administrator(self):
# Mock auth_handler.clear_cookie
user = "******"
MockAdmin = Mock()
MockAdmin.__iter__ = Mock(return_value=iter([]))
mock_clear_cookie = Mock()
with patch.object(settings, 'ADMINISTRATORS', MockAdmin):
with patch.object(self.auth_handler, 'clear_cookie', mock_clear_cookie):
self.auth_handler.set_admin(user)
mock_clear_cookie.assert_called_once_with('admin')
def queryset(self):
"""Mock "queryset" of instances with numeric id and unicode repr."""
o1 = Mock()
o1.pk = 1
o1.__unicode__ = lambda self: "one"
o2 = Mock()
o2.pk = 2
o2.__unicode__ = lambda self: "two"
qs = Mock()
qs.__iter__ = lambda self: iter([o1, o2])
qs.all.return_value = qs
return qs
def queryset(self):
"""Mock "queryset" of instances with numeric id and unicode repr."""
o1 = Mock()
o1.pk = 1
o1.__unicode__ = lambda self: "one"
o2 = Mock()
o2.pk = 2
o2.__unicode__ = lambda self: "two"
qs = Mock()
qs.__iter__ = lambda self: iter([o1, o2])
qs.all.return_value = qs
return qs
def make_mock_manifest(*items):
rv = Mock(tests_root="/foobar")
tests = []
rv.__iter__ = lambda self: iter(tests)
rv.__getitem__ = lambda self, k: tests[k]
for test_type, dir_path, num_tests in items:
for i in range(num_tests):
filename = dir_path + "/%i.html" % i
tests.append((test_type,
filename,
{TestharnessTest("/foo.bar", filename, "/", filename)}))
return rv
def make_mock_manifest(*items):
rv = Mock(tests_root="/foobar")
tests = []
rv.__iter__ = lambda self: iter(tests)
rv.__getitem__ = lambda self, k: tests[k]
for test_type, dir_path, num_tests in items:
for i in range(num_tests):
filename = dir_path + "/%i.html" % i
tests.append((test_type,
filename,
{TestharnessTest("/foo.bar", filename, "/", filename)}))
return rv
def test_step_status_is_collected_and_reported(self, format_summary,
stdout):
feature = Mock()
scenario = Mock()
steps = [Mock(), Mock(), Mock(), Mock(), Mock()]
steps[0].status = Status.failed
steps[0].__iter__ = Mock(return_value=iter([]))
steps[1].status = Status.passed
steps[1].__iter__ = Mock(return_value=iter([]))
steps[2].status = Status.passed
steps[2].__iter__ = Mock(return_value=iter([]))
steps[3].status = Status.skipped
steps[4].__iter__ = Mock(return_value=iter([]))
steps[4].status = Status.undefined
steps[4].__iter__ = Mock(return_value=iter([]))
feature.status = Status.failed
feature.duration = 12.3
feature.__iter__ = Mock(return_value=iter([scenario]))
scenario.status = Status.failed
scenario.__iter__ = Mock(return_value=iter(steps))
config = Mock()
sys.stdout.encoding = "UTF-8"
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
"all": 5,
Status.passed.name: 2,
Status.failed.name: 1,
Status.skipped.name: 1,
Status.untested.name: 0,
Status.undefined.name: 1,
}
step_index = 2 # HINT: Index for steps if not rules are used.
expected_parts = ("step", expected)
assert format_summary.call_args_list[step_index][0] == expected_parts
def test_step_status_is_collected_and_reported(self, format_summary,
stdout):
feature = Mock()
scenario = Mock()
steps = [Mock(), Mock(), Mock(), Mock(), Mock()]
steps[0].status = Status.failed
steps[0].__iter__ = Mock(return_value=iter([]))
steps[1].status = Status.passed
steps[1].__iter__ = Mock(return_value=iter([]))
steps[2].status = Status.passed
steps[2].__iter__ = Mock(return_value=iter([]))
steps[3].status = Status.skipped
steps[4].__iter__ = Mock(return_value=iter([]))
steps[4].status = Status.undefined
steps[4].__iter__ = Mock(return_value=iter([]))
feature.status = Status.failed
feature.duration = 12.3
feature.__iter__ = Mock(return_value=iter([scenario]))
scenario.status = Status.failed
scenario.__iter__ = Mock(return_value=iter(steps))
config = Mock()
sys.stdout.encoding = "UTF-8"
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
"all": 5,
Status.passed.name: 2,
Status.failed.name: 1,
Status.skipped.name: 1,
Status.untested.name: 0,
Status.undefined.name: 1,
}
step_index = 2 # HINT: Index for steps if not rules are used.
expected_parts = ("step", expected)
assert format_summary.call_args_list[step_index][0] == expected_parts
def test_widget(self):
subfield_1 = Mock(name='subfield_1')
subfield_1.return_value = u'[first input]'
subfield_2 = Mock(name='subfield_2')
subfield_2.return_value = u'[second input]'
field = Mock(name='field')
field.style = {'style': 'display:none;'}
field.__iter__ = Mock(return_value=iter([subfield_1, subfield_2]))
widget = HoneyPotWidget()
actual = widget(field)
subfield_2.assert_called_with(style='display:none;')
subfield_1.assert_called_with(style='display:none;')
self.assertEqual(actual, '[first input][second input]')
def fake_et_iterator(parent):
"""Fake iterator over child elements."""
def internal_fake_iterator(parent):
while False:
yield None
xml_element1 = Mock()
xml_element1.tag = 'simpleexpression'
xml_element1.__iter__ = internal_fake_iterator
elements = [xml_element1]
for elem in elements:
yield elem
def _fake_test(self, *args, **kwargs):
_fake_test.called = True
self._raw_data = _fake_raw_data
metrics_mock = metrics_mock_class()
preds = Mock()
preds.size = 100
preds.__iter__ = Mock(return_value=iter([0] * 100))
metrics_mock._preds = preds
metrics_mock._probs = [numpy.array([0.1, 0.2])] * 100
metrics_mock._true_data = scipy.sparse.coo_matrix(
[[0, 0, 0]] * 100)
return metrics_mock
def execute_query_se(query, arraysize):
if STARTOF_MINMAX_QUERY in query:
mock_query_results_config = {'get_col_index.return_value': 1}
mock_query_results = Mock(**mock_query_results_config)
mock_query_results.__iter__ = Mock(return_value=iter([[1, 2]]))
elif "FROM v$logmnr_contents" in query:
mock_query_results_config = {
'get_col_index.return_value':
1,
'fetchone.return_value':
(None if not logminer_results_deque else
logminer_results_deque.popleft())
}
mock_query_results = Mock(**mock_query_results_config)
# Mock a single result with two columns returned
mock_query_results.__iter__ = Mock(
return_value=iter(logminer_results_deque))
else:
mock_query_results_config = {
'fetchall.return_value': [('schema', 'table')]
}
mock_query_results = Mock(**mock_query_results_config)
mock_query_results.__iter__ = Mock(return_value=iter([]))
return mock_query_results
def test_pagination_es_query_no_data(self):
request = Mock()
request.query_params = {'limit': 20, 'offset': 30}
search_result = Mock()
search_result.hits = Mock()
search_result.hits.total = 0
search_result.__iter__ = Mock(return_value=iter([]))
query = Mock()
query.__getitem__ = Mock(return_value=query)
query.execute.return_value = search_result
pagination = ESQueryPagination()
paginated_query = pagination.paginate_es_query(query, request)
expect(paginated_query).to.eq([])
def testLenContainsIter(self):
mock = Mock()
self.assertRaises(TypeError, len, mock)
self.assertRaises(TypeError, iter, mock)
self.assertRaises(TypeError, lambda: 'foo' in mock)
mock.__len__ = lambda s: 6
self.assertEqual(len(mock), 6)
mock.__contains__ = lambda s, o: o == 3
self.assertTrue(3 in mock)
self.assertFalse(6 in mock)
mock.__iter__ = lambda s: iter('foobarbaz')
self.assertEqual(list(mock), list('foobarbaz'))
def testLenContainsIter(self):
mock = Mock()
self.assertRaises(TypeError, len, mock)
self.assertRaises(TypeError, iter, mock)
self.assertRaises(TypeError, lambda: 'foo' in mock)
mock.__len__ = lambda s: 6
self.assertEqual(len(mock), 6)
mock.__contains__ = lambda s, o: o == 3
self.assertTrue(3 in mock)
self.assertFalse(6 in mock)
mock.__iter__ = lambda s: iter('foobarbaz')
self.assertEqual(list(mock), list('foobarbaz'))
def test_len_contains_iter(self):
mock = Mock()
self.assertRaises(TypeError, len, mock)
self.assertRaises(TypeError, iter, mock)
self.assertRaises(TypeError, lambda: 'foo' in mock)
mock.__len__ = lambda s: 6
self.assertEqual(len(mock), 6)
mock.__contains__ = lambda s, o: o == 3
self.assertIn(3, mock)
self.assertNotIn(6, mock)
mock.__iter__ = lambda s: iter('foobarbaz')
self.assertEqual(list(mock), list('foobarbaz'))
def test_len_contains_iter(self):
mock = Mock()
self.assertRaises(TypeError, len, mock)
self.assertRaises(TypeError, iter, mock)
self.assertRaises(TypeError, lambda: 'foo' in mock)
mock.__len__ = lambda s: 6
self.assertEqual(len(mock), 6)
mock.__contains__ = lambda s, o: o == 3
self.assertIn(3, mock)
self.assertNotIn(6, mock)
mock.__iter__ = lambda s: iter('foobarbaz')
self.assertEqual(list(mock), list('foobarbaz'))
def get_fake_db():
""" Return a fake MongoDB """
fake_mongo = Mock(stream_mode=False)
values = [2, 3]
def fake_next():
if not values:
return None
return values.pop()
def fake_iter():
return iter([])
fake_mongo.__next__ = fake_next
fake_mongo.__iter__ = fake_iter
return fake_mongo
def test_scenario_outline_status_is_collected_and_reported(
self, stdout, format_summary):
feature = Mock()
scenarios = [
ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"),
Mock(),
Mock(),
Mock()
]
subscenarios = [Mock(), Mock(), Mock(), Mock()]
subscenarios[0].status = Status.passed
subscenarios[0].__iter__ = Mock(return_value=iter([]))
subscenarios[1].status = Status.failed
subscenarios[1].__iter__ = Mock(return_value=iter([]))
subscenarios[2].status = Status.failed
subscenarios[2].__iter__ = Mock(return_value=iter([]))
subscenarios[3].status = Status.skipped
subscenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[0]._scenarios = subscenarios
scenarios[1].status = Status.failed
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = Status.skipped
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = Status.passed
scenarios[3].__iter__ = Mock(return_value=iter([]))
feature.status = Status.failed
feature.duration = 12.4
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
sys.stdout.encoding = "UTF-8"
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
"all": 7,
Status.passed.name: 2,
Status.failed.name: 3,
Status.skipped.name: 2,
Status.untested.name: 0,
}
scenario_index = 1 # -- HINT: Index for scenarios if no Rules are used.
expected_parts = ("scenario", expected)
assert format_summary.call_args_list[scenario_index][
0] == expected_parts
def test_default_refresh_config(self, nest_mock):
dev = SpikeRecorder()
neurons = Mock()
neurons.__iter__ = Mock(return_value=iter([]))
dev.connect(neurons)
nest_mock.GetStatus.return_value = [{
'times': [0, 8, 15],
'senders': [8, 9, 10]
}]
neurons.id_to_index = TestSpikeRecorder.id_to_index
dev.refresh(0.0)
spikes = dev.times
self.assertEqual(3, len(spikes))
print spikes
self.assertEqual(8.0, spikes[0][0])
def test_checkout_deliveries():
partition = Mock(
get_total=Mock(return_value=Price(10, currency=settings.DEFAULT_CURRENCY)),
get_price_per_item=Mock(return_value=Price(10, currency=settings.DEFAULT_CURRENCY)))
def f():
yield partition
partition.__iter__ = Mock(return_value=f())
cart = Mock(partition=Mock(return_value=[partition]),
currency=settings.DEFAULT_CURRENCY)
checkout = Checkout(
cart, AnonymousUser(), 'tracking_code')
deliveries = list(checkout.deliveries)
assert deliveries[0][1] == Price(0, currency=settings.DEFAULT_CURRENCY)
assert deliveries[0][2] == partition.get_total()
assert deliveries[0][0][0][0] == partition
def test_checkout_deliveries():
partition = Mock(
get_total=Mock(return_value=Price(10, currency=settings.DEFAULT_CURRENCY)),
get_price_per_item=Mock(return_value=Price(10, currency=settings.DEFAULT_CURRENCY)))
def f():
yield partition
partition.__iter__ = Mock(return_value=f())
cart = Mock(partition=Mock(return_value=[partition]),
currency=settings.DEFAULT_CURRENCY)
checkout = Checkout(
cart, AnonymousUser(), 'tracking_code')
deliveries = list(checkout.deliveries)
assert deliveries[0][1] == Price(0, currency=settings.DEFAULT_CURRENCY)
assert deliveries[0][2] == partition.get_total()
assert deliveries[0][0][0][0] == partition
def test_use_indices_config(self, nest_mock):
dev = SpikeRecorder(use_ids=False)
neurons = Mock()
neurons.__iter__ = Mock(return_value=iter([1]))
neurons.grandparent = Mock()
populationView = Mock()
neurons.grandparent.__getitem__ = populationView
neurons.grandparent.all_cells = [1]
dev.connect(neurons)
recorder_device = neurons.grandparent.recorder
recorder_device.reset.assert_called_once_with()
populationView().record.assert_called_once_with("spikes",
to_file=False)
nest_mock.SetStatus.assert_any_call(
recorder_device._spike_detector.device, {"to_memory": True})
nest_mock.SetStatus.assert_any_call(
recorder_device._spike_detector.device, {"to_file": False})
self.assertDictEqual(dev._parameters, {'use_ids': False})
def test_paginate_es_query(self):
allegation = AllegationFactory(crid=123456)
attachment_1 = AttachmentFileFactory(id=1,
allegation=allegation,
title='Document Title 1',
text_content='Text Content 1')
attachment_2 = AttachmentFileFactory(id=2,
allegation=allegation,
title='Document Title 2',
text_content='Text Content 2')
AttachmentFileFactory(id=3,
allegation=allegation,
title='Document Title 3',
text_content='Text Content 3')
queryset = AttachmentFile.objects.all()
class MockObject(object):
pass
returned_value_1 = MockObject()
returned_value_2 = MockObject()
setattr(returned_value_1, 'id', 1)
setattr(returned_value_2, 'id', 2)
request = Mock()
request.query_params = {'limit': 20, 'offset': 30}
search_result = Mock()
search_result.hits = Mock()
search_result.hits.total = 50
search_result.__iter__ = Mock(
return_value=iter([returned_value_1, returned_value_2]))
query = Mock()
query.__getitem__ = Mock(return_value=query)
query.execute.return_value = search_result
pagination = ESQuerysetPagination()
paginated_query = pagination.paginate_es_query(query, request,
queryset)
expect(list(paginated_query)).to.eq([attachment_1, attachment_2])
expect(pagination.count).to.eq(50)
expect(pagination.limit).to.eq(20)
expect(pagination.offset).to.eq(30)
expect(pagination.request).to.eq(request)
def test_scenario_outline_status_is_collected_and_reported(
self, stdout, format_summary):
feature = Mock()
scenarios = [
ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"),
Mock(),
Mock(),
Mock()
]
subscenarios = [Mock(), Mock(), Mock(), Mock()]
subscenarios[0].status = Status.passed
subscenarios[0].__iter__ = Mock(return_value=iter([]))
subscenarios[1].status = Status.failed
subscenarios[1].__iter__ = Mock(return_value=iter([]))
subscenarios[2].status = Status.failed
subscenarios[2].__iter__ = Mock(return_value=iter([]))
subscenarios[3].status = Status.skipped
subscenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[0]._scenarios = subscenarios
scenarios[1].status = Status.failed
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = Status.skipped
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = Status.passed
scenarios[3].__iter__ = Mock(return_value=iter([]))
feature.status = Status.failed
feature.duration = 12.4
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
sys.stdout.encoding = "UTF-8"
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
Status.passed.name: 2,
Status.failed.name: 3,
Status.skipped.name: 2,
Status.untested.name: 0,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_scenario_outline_status_is_collected_and_reported(
self, stderr, format_summary):
feature = Mock()
scenarios = [
ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"),
Mock(),
Mock(),
Mock()
]
subscenarios = [Mock(), Mock(), Mock(), Mock()]
subscenarios[0].status = 'passed'
subscenarios[0].__iter__ = Mock(return_value=iter([]))
subscenarios[1].status = 'failed'
subscenarios[1].__iter__ = Mock(return_value=iter([]))
subscenarios[2].status = 'failed'
subscenarios[2].__iter__ = Mock(return_value=iter([]))
subscenarios[3].status = 'skipped'
subscenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[0]._scenarios = subscenarios
scenarios[1].status = 'failed'
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = 'skipped'
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = 'passed'
scenarios[3].__iter__ = Mock(return_value=iter([]))
feature.status = 'failed'
feature.duration = 12.4
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
'passed': 2,
'failed': 3,
'skipped': 2,
'untested': 0,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_paginate_es_query(self):
request = Mock()
request.query_params = {'limit': 20, 'offset': 30}
search_result = Mock()
search_result.hits = Mock()
search_result.hits.total = 50
search_result.__iter__ = Mock(return_value=iter([1, 2, 3]))
query = Mock()
query.__getitem__ = Mock(return_value=query)
query.execute.return_value = search_result
pagination = ESQueryPagination()
paginated_query = pagination.paginate_es_query(query, request)
query.__getitem__.assert_called_with(slice(30, 50))
expect(paginated_query).to.eq([1, 2, 3])
expect(pagination.count).to.eq(50)
expect(pagination.limit).to.eq(20)
expect(pagination.offset).to.eq(30)
expect(pagination.request).to.eq(request)
def test_reprocess_events(self):
event1 = Mock(spec=Event)
event1.process.return_value = True # processed
event2 = Mock(spec=Event)
event2.process.return_value = False # not processed
events = [event1, event2]
modeladmin_mock = Mock()
request_mock = Mock()
queryset = Mock()
queryset.__iter__ = Mock(return_value=iter(events))
queryset.count.return_value = len(events)
reprocess_events(modeladmin_mock, request_mock, queryset)
event1.process.assert_called_with(force=True)
event2.process.assert_called_with(force=True)
modeladmin_mock.message_user.assert_called_with(
request_mock, "1/2 event(s) successfully re-processed.")
def test_scenario_outline_status_is_collected_and_reported(self, stdout,
format_summary):
feature = Mock()
scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"),
Mock(), Mock(), Mock() ]
subscenarios = [ Mock(), Mock(), Mock(), Mock() ]
subscenarios[0].status = Status.passed
subscenarios[0].__iter__ = Mock(return_value=iter([]))
subscenarios[1].status = Status.failed
subscenarios[1].__iter__ = Mock(return_value=iter([]))
subscenarios[2].status = Status.failed
subscenarios[2].__iter__ = Mock(return_value=iter([]))
subscenarios[3].status = Status.skipped
subscenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[0]._scenarios = subscenarios
scenarios[1].status = Status.failed
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = Status.skipped
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = Status.passed
scenarios[3].__iter__ = Mock(return_value=iter([]))
feature.status = Status.failed
feature.duration = 12.4
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
sys.stdout.encoding = "UTF-8"
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
"all": 7,
Status.passed.name: 2,
Status.failed.name: 3,
Status.skipped.name: 2,
Status.untested.name: 0,
}
scenario_index = 1 # -- HINT: Index for scenarios if no Rules are used.
expected_parts = ("scenario", expected)
assert format_summary.call_args_list[scenario_index][0] == expected_parts
def test_angle_brackets_in_schema():
''' Serializer is able to find a type that matches schema in angle-bracket
notation. '''
class FakeSerializer(TypeRegistrySerializationBase):
# We don't need docstrings here. pylint: disable=C0111
signature = 42
def serialize_int(self, data):
pass
def deserialize_int(self, data):
pass
registry = Mock()
registry.primitives = [int]
registry.__iter__ = Mock(side_effect=lambda: iter([int]))
serializer = FakeSerializer(registry)
# test that the following function call does *not* raise any exceptions
serializer.schema_to_type('TimeSeries<int>')
def test_scenario_outline_status_is_collected_and_reported(self, stdout,
format_summary):
# FIX: issue40
# ENSURE: ScenarioOutline's scenarios are walked and collected.
feature = Mock()
scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"),
Mock(), Mock(), Mock() ]
subscenarios = [ Mock(), Mock(), Mock(), Mock() ]
subscenarios[0].status = 'passed'
subscenarios[0].__iter__ = Mock(return_value=iter([]))
subscenarios[1].status = 'failed'
subscenarios[1].__iter__ = Mock(return_value=iter([]))
subscenarios[2].status = 'failed'
subscenarios[2].__iter__ = Mock(return_value=iter([]))
subscenarios[3].status = 'skipped'
subscenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[0]._scenarios = subscenarios
scenarios[1].status = 'failed'
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = 'skipped'
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = 'passed'
scenarios[3].__iter__ = Mock(return_value=iter([]))
feature.status = 'failed'
feature.duration = 12.4
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
'passed': 2,
'failed': 3,
'skipped': 2,
'untested': 0,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_parses_feature_files_and_appends_to_feature_list(self, abspath, parse_file):
feature_files = ["one", "two", "three"]
feature = Mock()
feature.tags = []
feature.__iter__ = Mock(return_value=iter([]))
feature.run.return_value = False
self.runner.feature_files.return_value = feature_files
abspath.side_effect = lambda x: x.upper()
self.config.lang = "fritz"
self.config.format = ["plain"]
self.config.output.encoding = None
self.config.exclude = lambda s: False
self.config.junit = False
self.config.summary = False
parse_file.return_value = feature
self.runner.run_with_paths()
expected_parse_file_args = [((x.upper(),), {"language": "fritz"}) for x in feature_files]
eq_(parse_file.call_args_list, expected_parse_file_args)
eq_(self.runner.features, [feature] * 3)
def test_dir(self):
mock = Mock()
attrs = set(dir(mock))
type_attrs = set([m for m in dir(Mock) if not m.startswith('_')])
# all public attributes from the type are included
self.assertEqual(set(), type_attrs - attrs)
# creates these attributes
mock.a, mock.b
self.assertIn('a', dir(mock))
self.assertIn('b', dir(mock))
# instance attributes
mock.c = mock.d = None
self.assertIn('c', dir(mock))
self.assertIn('d', dir(mock))
# magic methods
mock.__iter__ = lambda s: iter([])
self.assertIn('__iter__', dir(mock))
def test_scenario_outline_status_is_collected_and_reported(self, stdout,
format_summary):
feature = Mock()
scenarios = [ ScenarioOutline(u"<string>", 0, u"scenario_outline", u"name"),
Mock(), Mock(), Mock() ]
subscenarios = [ Mock(), Mock(), Mock(), Mock() ]
subscenarios[0].status = Status.passed
subscenarios[0].__iter__ = Mock(return_value=iter([]))
subscenarios[1].status = Status.failed
subscenarios[1].__iter__ = Mock(return_value=iter([]))
subscenarios[2].status = Status.failed
subscenarios[2].__iter__ = Mock(return_value=iter([]))
subscenarios[3].status = Status.skipped
subscenarios[3].__iter__ = Mock(return_value=iter([]))
scenarios[0]._scenarios = subscenarios
scenarios[1].status = Status.failed
scenarios[1].__iter__ = Mock(return_value=iter([]))
scenarios[2].status = Status.skipped
scenarios[2].__iter__ = Mock(return_value=iter([]))
scenarios[3].status = Status.passed
scenarios[3].__iter__ = Mock(return_value=iter([]))
feature.status = Status.failed
feature.duration = 12.4
feature.__iter__ = Mock(return_value=iter(scenarios))
config = Mock()
sys.stdout.encoding = "UTF-8"
reporter = SummaryReporter(config)
reporter.feature(feature)
reporter.end()
expected = {
Status.passed.name: 2,
Status.failed.name: 3,
Status.skipped.name: 2,
Status.untested.name: 0,
}
eq_(format_summary.call_args_list[1][0], ('scenario', expected))
def test_magic_methods_and_spec_set(self):
class Iterable(object):
def __iter__(self): pass
mock = Mock(spec_set=Iterable)
self.assertRaises(AttributeError, lambda: mock.__iter__)
mock.__iter__ = Mock(return_value=iter([]))
self.assertEqual(list(mock), [])
class NonIterable(object):
pass
mock = Mock(spec_set=NonIterable)
self.assertRaises(AttributeError, lambda: mock.__iter__)
def set_int():
mock.__int__ = Mock(return_value=iter([]))
self.assertRaises(AttributeError, set_int)
mock = MagicMock(spec_set=Iterable)
self.assertEqual(list(mock), [])
self.assertRaises(AttributeError, set_int)
def test_parses_feature_files_and_appends_to_feature_list(self, abspath,
parse_file):
feature_locations = ['one', 'two', 'three']
feature = Mock()
feature.tags = []
feature.__iter__ = Mock(return_value=iter([]))
feature.run.return_value = False
self.runner.feature_locations.return_value = feature_locations
abspath.side_effect = lambda x: x.upper()
self.config.lang = 'fritz'
self.config.format = ['plain']
self.config.outputs = [ StreamOpener(stream=sys.stdout) ]
self.config.output.encoding = None
self.config.exclude = lambda s: False
self.config.junit = False
self.config.summary = False
parse_file.return_value = feature
self.runner.run_with_paths()
expected_parse_file_args = \
[((x.upper(),), {'language': 'fritz'}) for x in feature_locations]
eq_(parse_file.call_args_list, expected_parse_file_args)
eq_(self.runner.features, [feature] * 3)
#! coding: utf-8
from datetime import datetime
from mock import patch, Mock
#from itertools import permutations
import itertools
def real(name):
for i in itertools.permutations(xrange(len(name))):
print i
#real("abcabcabcabc")
with patch('itertools.permutations') as perm_mock:
perm_mock.return_value = [
(0, 1, 2, 7, 5, 9, 11, 6, 10, 3, 8, 4),
(0, 1, 2, 7, 5, 9, 11, 6, 10, 4, 3, 8)
]
real("abcabcabcabc")
mock_file = Mock()
mock_file.name = 'my_filename.doc'
mock_file.__iter__ = Mock(return_value = iter(['строка 1', 'строка 2', 'строка 3']))
stat = mock_file.stat.return_value
stat.size, stat.access_time = 1000, datetime(2012, 1, 1)
for line in mock_file:
print line
print mock_file
print mock_file.name
print mock_file.name2
def create_document_list(*docs):
doc_list_mock = Mock()
doc_list_mock.__iter__ = Mock()
doc_list_mock.__iter__.return_value = iter(docs)
return doc_list_mock
