def get_factory_from_step_or_factory(step_or_factory):
if hasattr(step_or_factory, 'get_step_factory'):
factory = step_or_factory.get_step_factory()
else:
factory = step_or_factory
# make sure the returned value actually implements IBuildStepFactory
return interfaces.IBuildStepFactory(factory)
def addStep(self, step, **kwargs):
if kwargs or (isinstance(step, type(BuildStep)) and issubclass(step, BuildStep)):
warnings.warn(
"Passing a BuildStep subclass to factory.addStep is "
"deprecated. Please pass a BuildStep instance instead.",
DeprecationWarning, stacklevel=2)
step = step(**kwargs)
self.steps.append(interfaces.IBuildStepFactory(step))
def addStep(self, step, **kwargs):
if kwargs or (isinstance(step, type(BuildStep))
and issubclass(step, BuildStep)):
warn_deprecated(
"0.8.8", "Passing a BuildStep subclass to factory.addStep is "
"deprecated. Please pass a BuildStep instance instead.")
step = step(**kwargs)
self.steps.append(interfaces.IBuildStepFactory(step))
def newBuild(self, requests):
"""Create a new Build instance.
@param requests: a list of buildrequest dictionaries describing what is
to be built
"""
build_class = self.buildClass(requests)
build_class.useProgress = self.useProgress
build_class.workdir = self.workdir
generated_steps = []
for step in self.steps:
if isinstance(step, ExpandingStep):
for gstep in step.closure(self):
generated_steps.append(interfaces.IBuildStepFactory(gstep))
else:
generated_steps.append(step)
build_class.setStepFactories(generated_steps)
return build_class
def _addBuildSteps(self, step_factories):
factories = [interfaces.IBuildStepFactory(s) for s in step_factories]
return self.setupBuildSteps(factories)
def setupStep(self, step, worker_version=None, worker_env=None,
buildFiles=None, wantDefaultWorkdir=True, wantData=True,
wantDb=False, wantMq=False):
"""
Set up C{step} for testing. This begins by using C{step} as a factory
to create a I{new} step instance, thereby testing that the factory
arguments are handled correctly. It then creates a comfortable
environment for the worker to run in, replete with a fake build and a
fake worker.
As a convenience, it can set the step's workdir with C{'wkdir'}.
@param worker_version: worker version to present, as a dictionary mapping
command name to version. A command name of '*' will apply for all
commands.
@param worker_env: environment from the worker at worker startup
@param wantData(bool): Set to True to add data API connector to master.
Default value: True.
@param wantDb(bool): Set to True to add database connector to master.
Default value: False.
@param wantMq(bool): Set to True to add mq connector to master.
Default value: False.
"""
if worker_version is None:
worker_version = {
'*': '99.99'
}
if worker_env is None:
worker_env = dict()
if buildFiles is None:
buildFiles = list()
factory = interfaces.IBuildStepFactory(step)
step = self.step = factory.buildStep()
self.master = fakemaster.make_master(wantData=wantData, wantDb=wantDb,
wantMq=wantMq, testcase=self)
# mock out the reactor for updateSummary's debouncing
self.debounceClock = task.Clock()
self.master.reactor = self.debounceClock
# set defaults
if wantDefaultWorkdir:
step.workdir = step._workdir or 'wkdir'
# step.build
b = self.build = fakebuild.FakeBuild(master=self.master)
b.allFiles = lambda: buildFiles
b.master = self.master
def getWorkerVersion(cmd, oldversion):
if cmd in worker_version:
return worker_version[cmd]
if '*' in worker_version:
return worker_version['*']
return oldversion
b.getWorkerCommandVersion = getWorkerVersion
b.workerEnvironment = worker_env.copy()
step.setBuild(b)
# watch for properties being set
self.properties = interfaces.IProperties(b)
# step.progress
step.progress = mock.Mock(name="progress")
# step.worker
self.worker = step.worker = worker.FakeWorker(self.master)
# step overrides
def addLog(name, type='s', logEncoding=None):
_log = logfile.FakeLogFile(name, step)
self.step.logs[name] = _log
return defer.succeed(_log)
step.addLog = addLog
step.addLog_newStyle = addLog
def addHTMLLog(name, html):
_log = logfile.FakeLogFile(name, step)
html = bytes2NativeString(html)
_log.addStdout(html)
return defer.succeed(None)
step.addHTMLLog = addHTMLLog
def addCompleteLog(name, text):
_log = logfile.FakeLogFile(name, step)
self.step.logs[name] = _log
_log.addStdout(text)
return defer.succeed(None)
step.addCompleteLog = addCompleteLog
step.logobservers = self.logobservers = {}
def addLogObserver(logname, observer):
self.logobservers.setdefault(logname, []).append(observer)
observer.step = step
step.addLogObserver = addLogObserver
# add any observers defined in the constructor, before this
# monkey-patch
for n, o in step._pendingLogObservers:
addLogObserver(n, o)
# expectations
self.exp_result = None
self.exp_state_string = None
self.exp_properties = {}
self.exp_missing_properties = []
self.exp_logfiles = {}
self.exp_hidden = False
self.exp_exception = None
# check that the step's name is not None
self.assertNotEqual(step.name, None)
return step
def prepend_step(self, step):
self.steps.insert(0, interfaces.IBuildStepFactory(step))
def setupStep(self, step, slave_version={'*': "99.99"}, slave_env={}):
"""
Set up C{step} for testing. This begins by using C{step} as a factory
to create a I{new} step instance, thereby testing that the the factory
arguments are handled correctly. It then creates a comfortable
environment for the slave to run in, repleate with a fake build and a
fake slave.
As a convenience, it calls the step's setDefaultWorkdir method with
C{'wkdir'}.
@param slave_version: slave version to present, as a dictionary mapping
command name to version. A command name of '*' will apply for all
commands.
@param slave_env: environment from the slave at slave startup
"""
factory = interfaces.IBuildStepFactory(step)
step = self.step = factory.buildStep()
self.master = fakemaster.make_master(testcase=self)
# step.build
b = self.build = fakebuild.FakeBuild()
b.master = self.master
def getSlaveVersion(cmd, oldversion):
if cmd in slave_version:
return slave_version[cmd]
if '*' in slave_version:
return slave_version['*']
return oldversion
b.getSlaveCommandVersion = getSlaveVersion
b.slaveEnvironment = slave_env.copy()
step.setBuild(b)
# watch for properties being set
self.properties = interfaces.IProperties(b)
# step.progress
step.progress = mock.Mock(name="progress")
# step.buildslave
self.master = fakemaster.make_master(testcase=self)
self.buildslave = step.buildslave = slave.FakeSlave(self.master)
# step.step_status
ss = self.step_status = mock.Mock(name="step_status")
ss.status_text = None
ss.logs = {}
def ss_setText(strings):
ss.status_text = strings
ss.setText = ss_setText
ss.getLogs = lambda: ss.logs.values()
self.step_statistics = {}
ss.setStatistic = self.step_statistics.__setitem__
ss.getStatistic = self.step_statistics.get
ss.hasStatistic = self.step_statistics.__contains__
self.step.setStepStatus(ss)
# step overrides
def addLog(name):
l = remotecommand.FakeLogFile(name, step)
ss.logs[name] = l
return l
step.addLog = addLog
def addHTMLLog(name, html):
l = remotecommand.FakeLogFile(name, step)
l.addStdout(html)
ss.logs[name] = l
return l
step.addHTMLLog = addHTMLLog
def addCompleteLog(name, text):
l = remotecommand.FakeLogFile(name, step)
l.addStdout(text)
ss.logs[name] = l
return l
step.addCompleteLog = addCompleteLog
step.logobservers = self.logobservers = {}
def addLogObserver(logname, observer):
self.logobservers.setdefault(logname, []).append(observer)
observer.step = step
step.addLogObserver = addLogObserver
# add any observers defined in the constructor, before this monkey-patch
for n, o in step._pendingLogObservers:
addLogObserver(n, o)
# set defaults
step.setDefaultWorkdir('wkdir')
# expectations
self.exp_outcome = None
self.exp_properties = {}
self.exp_missing_properties = []
self.exp_logfiles = {}
self.exp_hidden = False
# check that the step's name is not None
self.assertNotEqual(step.name, None)
return step
def s(steptype, **kwargs):
# convenience function for master.cfg files, to create step
# specification tuples
return interfaces.IBuildStepFactory(steptype(**kwargs))
def addStep(self, step):
self.steps.append(interfaces.IBuildStepFactory(step))
def setupStep(self,
step,
worker_version=None,
worker_env=None,
buildFiles=None,
wantDefaultWorkdir=True):
"""
Set up C{step} for testing. This begins by using C{step} as a factory
to create a I{new} step instance, thereby testing that the factory
arguments are handled correctly. It then creates a comfortable
environment for the worker to run in, replete with a fake build and a
fake worker.
As a convenience, it can set the step's workdir with C{'wkdir'}.
@param worker_version: worker version to present, as a dictionary mapping
command name to version. A command name of '*' will apply for all
commands.
@param worker_env: environment from the worker at worker startup
"""
if worker_version is None:
worker_version = {'*': '99.99'}
if worker_env is None:
worker_env = dict()
if buildFiles is None:
buildFiles = list()
factory = interfaces.IBuildStepFactory(step)
step = self.step = factory.buildStep()
# set defaults
if wantDefaultWorkdir:
step.workdir = step._workdir or 'wkdir'
# step.build
b = self.build = fakebuild.FakeBuild(master=self.master)
b.allFiles = lambda: buildFiles
b.master = self.master
def getWorkerVersion(cmd, oldversion):
if cmd in worker_version:
return worker_version[cmd]
if '*' in worker_version:
return worker_version['*']
return oldversion
b.getWorkerCommandVersion = getWorkerVersion
b.workerEnvironment = worker_env.copy()
step.setBuild(b)
# watch for properties being set
self.properties = interfaces.IProperties(b)
# step.progress
step.progress = mock.Mock(name="progress")
# step.worker
self.worker = step.worker = worker.FakeWorker(self.master)
self.worker.attached(None)
# step overrides
def addLog(name, type='s', logEncoding=None):
_log = logfile.FakeLogFile(name, step)
self.step.logs[name] = _log
return defer.succeed(_log)
step.addLog = addLog
step.addLog_newStyle = addLog
def addHTMLLog(name, html):
_log = logfile.FakeLogFile(name, step)
html = bytes2unicode(html)
_log.addStdout(html)
return defer.succeed(None)
step.addHTMLLog = addHTMLLog
def addCompleteLog(name, text):
_log = logfile.FakeLogFile(name, step)
self.step.logs[name] = _log
_log.addStdout(text)
return defer.succeed(None)
step.addCompleteLog = addCompleteLog
step.logobservers = self.logobservers = {}
def addLogObserver(logname, observer):
self.logobservers.setdefault(logname, []).append(observer)
observer.step = step
step.addLogObserver = addLogObserver
# add any observers defined in the constructor, before this
# monkey-patch
for n, o in step._pendingLogObservers:
addLogObserver(n, o)
self._got_test_result_sets = []
self._next_test_result_set_id = 1000
def add_test_result_set(description, category, value_unit):
self._got_test_result_sets.append(
(description, category, value_unit))
setid = self._next_test_result_set_id
self._next_test_result_set_id += 1
return defer.succeed(setid)
step.addTestResultSet = add_test_result_set
self._got_test_results = []
def add_test_result(setid,
value,
test_name=None,
test_code_path=None,
line=None,
duration_ns=None):
self._got_test_results.append(
(setid, value, test_name, test_code_path, line, duration_ns))
step.addTestResult = add_test_result
# expectations
self.exp_result = None
self.exp_state_string = None
self.exp_properties = {}
self.exp_missing_properties = []
self.exp_logfiles = {}
self.exp_hidden = False
self.exp_exception = None
self._exp_test_result_sets = []
self._exp_test_results = []
# check that the step's name is not None
self.assertNotEqual(step.name, None)
return step
def setupStep(self,
step,
slave_version={'*': "99.99"},
slave_env={},
buildFiles=[]):
"""
Set up C{step} for testing. This begins by using C{step} as a factory
to create a I{new} step instance, thereby testing that the the factory
arguments are handled correctly. It then creates a comfortable
environment for the slave to run in, replete with a fake build and a
fake slave.
As a convenience, it calls the step's setDefaultWorkdir method with
C{'wkdir'}.
@param slave_version: slave version to present, as a dictionary mapping
command name to version. A command name of '*' will apply for all
commands.
@param slave_env: environment from the slave at slave startup
"""
factory = interfaces.IBuildStepFactory(step)
step = self.step = factory.buildStep()
self.master = fakemaster.make_master(wantData=True, testcase=self)
# step.build
b = self.build = fakebuild.FakeBuild(master=self.master)
b.allFiles = lambda: buildFiles
b.master = self.master
def getSlaveVersion(cmd, oldversion):
if cmd in slave_version:
return slave_version[cmd]
if '*' in slave_version:
return slave_version['*']
return oldversion
b.getSlaveCommandVersion = getSlaveVersion
b.slaveEnvironment = slave_env.copy()
step.setBuild(b)
# watch for properties being set
self.properties = interfaces.IProperties(b)
# step.progress
step.progress = mock.Mock(name="progress")
# step.buildslave
self.buildslave = step.buildslave = slave.FakeSlave(self.master)
# step overrides
def addLog(name, type='s', logEncoding=None):
l = logfile.FakeLogFile(name, step)
self.step.logs[name] = l
return defer.succeed(l)
step.addLog = addLog
step.addLog_newStyle = addLog
def addHTMLLog(name, html):
l = logfile.FakeLogFile(name, step)
l.addStdout(html)
return defer.succeed(None)
step.addHTMLLog = addHTMLLog
def addCompleteLog(name, text):
l = logfile.FakeLogFile(name, step)
self.step.logs[name] = l
l.addStdout(text)
return defer.succeed(None)
step.addCompleteLog = addCompleteLog
step.logobservers = self.logobservers = {}
def addLogObserver(logname, observer):
self.logobservers.setdefault(logname, []).append(observer)
observer.step = step
step.addLogObserver = addLogObserver
# add any observers defined in the constructor, before this
# monkey-patch
for n, o in step._pendingLogObservers:
addLogObserver(n, o)
# set defaults
step.setDefaultWorkdir('wkdir')
# expectations
self.exp_result = None
self.exp_state_strings = None
self.exp_properties = {}
self.exp_missing_properties = []
self.exp_logfiles = {}
self.exp_hidden = False
# check that the step's name is not None
self.assertNotEqual(step.name, None)
# mock out the reactor for updateSummary's debouncing
self.debounceClock = task.Clock()
step.updateSummary._reactor = self.debounceClock
return step
