def setUp(self):
""" Set up test fixtures. """
self.mock_tracker = scaffold.MockTracker()
pidlockfile_scenarios = make_pidlockfile_scenarios()
self.pidlockfile_scenario = pidlockfile_scenarios['simple']
pidfile_path = self.pidlockfile_scenario['path']
scaffold.mock(
u"pidlockfile.PIDLockFile.__init__",
tracker=self.mock_tracker)
scaffold.mock(
u"pidlockfile.PIDLockFile.acquire",
tracker=self.mock_tracker)
self.scenario = {
'pidfile_path': self.pidlockfile_scenario['path'],
'acquire_timeout': object(),
}
self.test_kwargs = dict(
path=self.scenario['pidfile_path'],
acquire_timeout=self.scenario['acquire_timeout'],
)
self.test_instance = daemon.pidfile.TimeoutPIDLockFile(
**self.test_kwargs)
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
def setup_pidfile_fixtures(testcase):
""" Set up common fixtures for PID file test cases. """
testcase.mock_tracker = scaffold.MockTracker()
scenarios = make_pidlockfile_scenarios()
testcase.pidlockfile_scenarios = scenarios
def get_scenario_option(testcase, key, default=None):
value = default
try:
value = testcase.scenario[key]
except (NameError, TypeError, AttributeError, KeyError):
pass
return value
scaffold.mock(u"os.getpid",
returns=scenarios['simple']['pid'],
tracker=testcase.mock_tracker)
def make_mock_open_funcs(testcase):
def mock_open_nonexist(filename, mode, buffering):
if 'r' in mode:
raise IOError(errno.ENOENT,
u"No such file %(filename)r" % vars())
else:
result = testcase.scenario['pidfile']
return result
def mock_open_read_denied(filename, mode, buffering):
if 'r' in mode:
raise IOError(errno.EPERM,
u"Read denied on %(filename)r" % vars())
else:
result = testcase.scenario['pidfile']
return result
def mock_open_okay(filename, mode, buffering):
result = testcase.scenario['pidfile']
return result
def mock_os_open_nonexist(filename, flags, mode):
if (flags & os.O_CREAT):
result = testcase.scenario['pidfile'].fileno()
else:
raise OSError(errno.ENOENT,
u"No such file %(filename)r" % vars())
return result
def mock_os_open_read_denied(filename, flags, mode):
if (flags & os.O_CREAT):
result = testcase.scenario['pidfile'].fileno()
else:
raise OSError(errno.EPERM,
u"Read denied on %(filename)r" % vars())
return result
def mock_os_open_okay(filename, flags, mode):
result = testcase.scenario['pidfile'].fileno()
return result
funcs = dict((name, obj) for (name, obj) in vars().items()
if hasattr(obj, '__call__'))
return funcs
testcase.mock_pidfile_open_funcs = make_mock_open_funcs(testcase)
def mock_open(filename, mode='r', buffering=None):
scenario_path = get_scenario_option(testcase, 'path')
if filename == scenario_path:
func_name = testcase.scenario['open_func_name']
mock_open_func = testcase.mock_pidfile_open_funcs[func_name]
result = mock_open_func(filename, mode, buffering)
else:
result = FakeFileDescriptorStringIO()
return result
scaffold.mock(u"builtins.open",
returns_func=mock_open,
tracker=testcase.mock_tracker)
def mock_os_open(filename, flags, mode=None):
scenario_path = get_scenario_option(testcase, 'path')
if filename == scenario_path:
func_name = testcase.scenario['os_open_func_name']
mock_os_open_func = testcase.mock_pidfile_open_funcs[func_name]
result = mock_os_open_func(filename, flags, mode)
else:
result = FakeFileDescriptorStringIO().fileno()
return result
scaffold.mock(u"os.open",
returns_func=mock_os_open,
tracker=testcase.mock_tracker)
def mock_os_fdopen(fd, mode='r', buffering=None):
scenario_pidfile = get_scenario_option(testcase, 'pidfile',
FakeFileDescriptorStringIO())
if fd == testcase.scenario['pidfile'].fileno():
result = testcase.scenario['pidfile']
else:
raise OSError(errno.EBADF, u"Bad file descriptor")
return result
scaffold.mock(u"os.fdopen",
returns_func=mock_os_fdopen,
tracker=testcase.mock_tracker)
testcase.scenario = NotImplemented
