def test_closes_file_after_write(self):
""" Should close the specified file after writing. """
pidfile_path = self.scenario['path']
self.scenario['pidfile'].write = scaffold.Mock(
u"PIDLockFile.write", tracker=self.mock_tracker)
self.scenario['pidfile'].close = scaffold.Mock(
u"PIDLockFile.close", tracker=self.mock_tracker)
expect_mock_output = u"""\
...
Called PIDLockFile.write(...)
Called PIDLockFile.close()
""" % vars()
pidlockfile.write_pid_to_pidfile(pidfile_path)
scaffold.mock_restore()
self.failUnlessMockCheckerMatch(expect_mock_output)
class TestApp(object):
def __init__(self):
self.stdin_path = testcase.stream_file_paths['stdin']
self.stdout_path = testcase.stream_file_paths['stdout']
self.stderr_path = testcase.stream_file_paths['stderr']
self.pidfile_path = simple_scenario['pidfile_path']
self.pidfile_timeout = simple_scenario['pidfile_timeout']
run = scaffold.Mock("TestApp.run", tracker=testcase.mock_tracker)
def test_writes_pid_to_file(self):
""" Should write the current PID to the specified file. """
pidfile_path = self.scenario['path']
self.scenario['pidfile'].close = scaffold.Mock(
u"PIDLockFile.close", tracker=self.mock_tracker)
expect_line = u"%(pid)d\n" % self.scenario
pidlockfile.write_pid_to_pidfile(pidfile_path)
scaffold.mock_restore()
self.failUnlessEqual(expect_line, self.scenario['pidfile'].getvalue())
def setup_lockfile_method_mocks(testcase, scenario, class_name):
""" Set up common mock methods for lockfile class. """
def mock_read_pid():
return scenario['pidfile_pid']
def mock_is_locked():
return (scenario['locking_pid'] is not None)
def mock_i_am_locking():
return (scenario['locking_pid'] == scenario['pid'])
def mock_acquire(timeout=None):
if scenario['locking_pid'] is not None:
raise lockfile.AlreadyLocked()
scenario['locking_pid'] = scenario['pid']
def mock_release():
if scenario['locking_pid'] is None:
raise lockfile.NotLocked()
if scenario['locking_pid'] != scenario['pid']:
raise lockfile.NotMyLock()
scenario['locking_pid'] = None
def mock_break_lock():
scenario['locking_pid'] = None
for func_name in [
'read_pid',
'is_locked',
'i_am_locking',
'acquire',
'release',
'break_lock',
]:
mock_func = vars()["mock_%(func_name)s" % vars()]
lockfile_func_name = u"%(class_name)s.%(func_name)s" % vars()
mock_lockfile_func = scaffold.Mock(lockfile_func_name,
returns_func=mock_func,
tracker=testcase.mock_tracker)
try:
scaffold.mock(lockfile_func_name,
mock_obj=mock_lockfile_func,
tracker=testcase.mock_tracker)
except NameError:
pass
def setup_runner_fixtures(testcase):
""" Set up common test fixtures for DaemonRunner test case. """
testcase.mock_tracker = scaffold.MockTracker()
setup_pidfile_fixtures(testcase)
setup_streams_fixtures(testcase)
testcase.runner_scenarios = make_runner_scenarios()
testcase.mock_stderr = FakeFileDescriptorStringIO()
scaffold.mock("sys.stderr",
mock_obj=testcase.mock_stderr,
tracker=testcase.mock_tracker)
simple_scenario = testcase.runner_scenarios['simple']
testcase.lockfile_class_name = "pidlockfile.TimeoutPIDLockFile"
testcase.mock_runner_lock = scaffold.Mock(testcase.lockfile_class_name,
tracker=testcase.mock_tracker)
testcase.mock_runner_lock.path = simple_scenario['pidfile_path']
scaffold.mock(testcase.lockfile_class_name,
returns=testcase.mock_runner_lock,
tracker=testcase.mock_tracker)
class TestApp(object):
def __init__(self):
self.stdin_path = testcase.stream_file_paths['stdin']
self.stdout_path = testcase.stream_file_paths['stdout']
self.stderr_path = testcase.stream_file_paths['stderr']
self.pidfile_path = simple_scenario['pidfile_path']
self.pidfile_timeout = simple_scenario['pidfile_timeout']
run = scaffold.Mock("TestApp.run", tracker=testcase.mock_tracker)
testcase.TestApp = TestApp
scaffold.mock("daemon.runner.DaemonContext",
returns=scaffold.Mock("DaemonContext",
tracker=testcase.mock_tracker),
tracker=testcase.mock_tracker)
testcase.test_app = testcase.TestApp()
testcase.test_program_name = "bazprog"
testcase.test_program_path = ("/foo/bar/%(test_program_name)s" %
vars(testcase))
testcase.valid_argv_params = {
'start': [testcase.test_program_path, 'start'],
'stop': [testcase.test_program_path, 'stop'],
'restart': [testcase.test_program_path, 'restart'],
}
def mock_open(filename, mode=None, buffering=None):
if filename in testcase.stream_files_by_path:
result = testcase.stream_files_by_path[filename]
else:
result = FakeFileDescriptorStringIO()
result.mode = mode
result.buffering = buffering
return result
scaffold.mock("builtins.open",
returns_func=mock_open,
tracker=testcase.mock_tracker)
scaffold.mock("os.kill", tracker=testcase.mock_tracker)
scaffold.mock("sys.argv",
mock_obj=testcase.valid_argv_params['start'],
tracker=testcase.mock_tracker)
testcase.test_instance = runner.DaemonRunner(testcase.test_app)
testcase.scenario = NotImplemented
