def test_all_fds_cleaned_up(self):
initial_open_fds = get_open_fds()
pool = vimap.pool.fork_identical(basic_worker, num_workers=1)
after_fork_open_fds = get_open_fds()
list(pool.imap([1, 2, 3]).zip_in_out())
after_finish_open_fds = get_open_fds()
# Check that some FDs were opened after forking
after_fork = difference_open_fds(initial_open_fds,
after_fork_open_fds)
# T.assert_equal(after_fork['closed'], [])
T.assert_gte(len(after_fork['opened']),
2) # should have at least 3 open fds
# All opened files should be FIFOs
if not all(info.modes == ['fifo'] for info in
after_fork['opened'].values()):
print("Infos: {0}".format(after_fork['opened']))
T.assert_not_reached("Some infos are not FIFOs")
after_cleanup = difference_open_fds(after_fork_open_fds,
after_finish_open_fds)
T.assert_gte(len(after_cleanup['closed']), 2)
left_around = difference_open_fds(initial_open_fds,
after_finish_open_fds)
if len(left_around['opened']) != 0:
queue_fds_left_around = dict(
item for item in self.queue_fds.items() if
item[0] in left_around['opened'])
print(
"Queue FDs left around: {0}".format(queue_fds_left_around))
T.assert_equal(len(left_around['opened']), 0)
def test_all_fds_cleaned_up(self):
initial_open_fds = get_open_fds()
pool = vimap.pool.fork_identical(basic_worker, num_workers=1)
after_fork_open_fds = get_open_fds()
list(pool.imap([1, 2, 3]).zip_in_out())
after_finish_open_fds = get_open_fds()
# Check that some FDs were opened after forking
after_fork = difference_open_fds(initial_open_fds, after_fork_open_fds)
# T.assert_equal(after_fork['closed'], [])
T.assert_gte(len(after_fork['opened']),
2) # should have at least 3 open fds
# All opened files should be FIFOs
if not all(info.modes == ['fifo']
for info in after_fork['opened'].values()):
print("Infos: {0}".format(after_fork['opened']))
T.assert_not_reached("Some infos are not FIFOs")
after_cleanup = difference_open_fds(after_fork_open_fds,
after_finish_open_fds)
T.assert_gte(len(after_cleanup['closed']), 2)
left_around = difference_open_fds(initial_open_fds,
after_finish_open_fds)
if len(left_around['opened']) != 0:
queue_fds_left_around = dict(item
for item in self.queue_fds.items()
if item[0] in left_around['opened'])
print("Queue FDs left around: {0}".format(queue_fds_left_around))
T.assert_equal(len(left_around['opened']), 0)
def test_fails_when_exception_is_not_raised(self):
raises_nothing = lambda: None
try:
assertions.assert_raises(ValueError, raises_nothing)
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_fails_when_exception_is_not_raised(self):
raises_nothing = lambda: None
try:
assertions.assert_raises(ValueError, raises_nothing)
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_fails_when_exception_is_not_raised(self):
def raises_nothing():
pass
try:
assertions.assert_raises_and_contains(ValueError, 'abc', raises_nothing)
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_fails_when_wrong_exception_is_raised(self):
def raises_value_error():
raise ValueError
try:
assertions.assert_raises(MyException, raises_value_error)
except ValueError:
pass
else:
assert_not_reached('ValueError should have been raised')
def test_fails_when_exception_does_not_contains_all_strings(self):
def raises_value_error():
raise ValueError('abc xyz')
try:
assertions.assert_raises_and_contains(ValueError, ['ABC', '123'], raises_value_error)
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_fails_when_wrong_exception_is_raised(self):
def raises_value_error():
raise ValueError
try:
assertions.assert_raises(MyException, raises_value_error)
except ValueError:
pass
else:
assert_not_reached('ValueError should have been raised')
def test_fails_when_exception_is_not_raised(self):
def raises_nothing():
pass
try:
assertions.assert_raises_and_contains(ValueError, 'abc',
raises_nothing)
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_message_on_fail(self):
superset = {'one': 1, 'two': 2, 'three': 3}
subset = {'one': 2, 'two':2}
expected = "expected [subset has:{'one': 2}, superset has:{'one': 1}]"
try:
assert_dict_subset(subset, superset)
except AssertionError as e:
assert_equal(expected, e.args[0])
else:
assert_not_reached('AssertionError should have been raised')
def test_message_on_fail(self):
superset = {'one': 1, 'two': 2, 'three': 3}
subset = {'one': 2, 'two': 2}
expected = "expected [subset has:{'one': 2}, superset has:{'one': 1}]"
try:
assert_dict_subset(subset, superset)
except AssertionError as e:
assert_equal(expected, e.args[0])
else:
assert_not_reached('AssertionError should have been raised')
def test_fails_when_exception_does_not_contains_all_strings(self):
def raises_value_error():
raise ValueError('abc xyz')
try:
assertions.assert_raises_and_contains(ValueError, ['ABC', '123'],
raises_value_error)
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_fails_when_exception_is_not_raised(self):
def exception_should_be_raised():
with assertions.assert_raises(MyException):
pass
try:
exception_should_be_raised()
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_fails_when_exception_is_not_raised(self):
def exception_should_be_raised():
with assertions.assert_raises(MyException):
pass
try:
exception_should_be_raised()
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def no_warnings():
'''Make vimap.exception_handling.print_warning fail tests.'''
import testify as T # in case you're not using testify
return mock.patch.object(
vimap.exception_handling,
'print_warning',
lambda *args, **kwargs: T.assert_not_reached())
class ExitWithoutExceptionTestCase(TestCase):
def test_exit_42_job(self):
mr_job = MRExit42Job(['--no-conf'])
mr_job.sandbox()
try:
mr_job.run_job()
except Exception, e:
assert_in('returned non-zero exit status 42', repr(e))
return
assert_not_reached()
def wrapper(method):
def on_timeout(d):
e = defer.TimeoutError("(%s) still running at %s secs" %
(method.__name__, timeout))
f = failure.Failure(e)
try:
d.errback(f)
except defer.AlreadyCalledError:
# if the deferred has been called already but the *back chain
# is still unfinished, crash the reactor and report timeout
# error ourself.
reactor.crash()
raise
@functools.wraps(method)
def run_defer(*args, **kwargs):
deferred = defer.maybeDeferred(method, *args, **kwargs)
call = reactor.callLater(timeout, on_timeout, deferred)
deferred.addBoth(lambda x: call.active() and call.cancel() or x)
found_error = False
try:
wait_for_deferred(deferred)
except TwistedFailureError, e:
if assert_raises:
d_fail = e.args[0]
if issubclass(d_fail.type, assert_raises):
found_error = True
else:
raise
if assert_raises and not found_error:
assert_not_reached("No exception was raised (expected %s)" %
assert_raises)
return None
def get_ec(self):
try:
raise self.err
except:
return exception_handling.ExceptionContext.current()
testify.assert_not_reached()
subset = {'one': 2}
assertions.assert_raises(AssertionError, assert_dict_subset, superset,
subset)
def test_message_on_fail(self):
superset = {'one': 1, 'two': 2, 'three': 3}
subset = {'one': 2, 'two': 2}
expected = "expected [subset has:{'one': 2}, superset has:{'one': 1}]"
try:
assert_dict_subset(subset, superset)
except AssertionError, e:
assert_equal(expected, e.args[0])
else:
assert_not_reached('AssertionError should have been raised')
class AssertEmptyTestCase(TestCase):
def test_passes_on_empty_list(self):
"""Test that assert_empty passes on an empty list."""
assertions.assert_empty([])
def test_passes_on_unyielding_generator(self):
"""Test that assert_empty passes on an 'empty' generator."""
def yield_nothing():
if False:
yield 0
assertions.assert_empty(yield_nothing())
superset = {'one': 1, 'two': 2, 'three': 3}
subset = {'one': 2}
assertions.assert_raises(AssertionError, assert_dict_subset, superset, subset)
def test_message_on_fail(self):
superset = {'one': 1, 'two': 2, 'three': 3}
subset = {'one': 2, 'two':2}
expected = "expected [subset has:{'one': 2}, superset has:{'one': 1}]"
try:
assert_dict_subset(subset, superset)
except AssertionError, e:
assert_equal(expected, e.args[0])
else:
assert_not_reached('AssertionError should have been raised')
class AssertEmptyTestCase(TestCase):
def test_passes_on_empty_list(self):
"""Test that assert_empty passes on an empty list."""
assertions.assert_empty([])
def test_passes_on_unyielding_generator(self):
"""Test that assert_empty passes on an 'empty' generator."""
def yield_nothing():
if False:
yield 0
assertions.assert_empty(yield_nothing())
def get_ec(self):
try:
raise self.err
except:
return exception_handling.ExceptionContext.current()
testify.assert_not_reached()
