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