def setUp(self):
@implementer(interfaces.IProperties)
class FakeProperties(Mock):
pass
FakeProperties.render = Mock(side_effect=lambda x: x)
class FakeBuildStatus(Mock):
pass
r = FakeRequest()
r.sources = [FakeSource()]
r.sources[0].changes = [FakeChange()]
r.sources[0].revision = "12345"
self.master = fakemaster.make_master(wantData=True, testcase=self)
self.worker = worker.FakeWorker(self.master)
self.worker.attached(None)
self.workerforbuilder = Mock(name='workerforbuilder')
self.workerforbuilder.worker = self.worker
self.build = Build([r])
self.build.setStepFactories([])
self.builder = FakeBuilder(
fakemaster.make_master(wantData=True, testcase=self))
self.build.setBuilder(self.builder)
self.properties = self.build.properties = FakeProperties()
self.build_status = FakeBuildStatus()
self.build._flushProperties = Mock()
self.build.startBuild(self.build_status, self.workerforbuilder)
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self)
# don't load by default
self.patch(connector.DataConnector, 'submodules', [])
self.data = connector.DataConnector()
self.data.setServiceParent(self.master)
def setUp(self):
self.setUpTestReactor()
self.reactor.advance(SOMETIME)
self.master = fakemaster.make_master(self, wantDb=True)
self.db = self.master.db
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantData=True, wantDb=True,
wantMq=True)
self.message = message.MessageFormatter()
self.messageMissing = message.MessageFormatterMissingWorker()
def setUp(self):
self.master = fakemaster.make_master(testcase=self, wantMq=True,
wantData=True, wantDb=True)
# set the worker port to a loopback address with unspecified
# port
self.pbmanager = self.master.pbmanager = pbmanager.PBManager()
self.pbmanager.setServiceParent(self.master)
# remove the fakeServiceParent from fake service hierarchy, and replace
# by a real one
yield self.master.workers.disownServiceParent()
self.workers = self.master.workers = workermanager.WorkerManager(
self.master)
self.workers.setServiceParent(self.master)
self.botmaster = botmaster.BotMaster()
self.botmaster.setServiceParent(self.master)
self.master.status = master.Status()
self.master.status.setServiceParent(self.master)
self.master.botmaster = self.botmaster
self.master.data.updates.workerConfigured = lambda *a, **k: None
yield self.master.startService()
self.buildworker = None
self.port = None
self.workerworker = None
self.connector = None
self._detach_deferreds = []
# patch in our FakeBuilder for the regular Builder class
self.patch(botmaster, 'Builder', FakeBuilder)
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantDb=True, wantData=True)
self.botmaster = self.master.botmaster
self.master.workers.disownServiceParent()
self.workers = self.master.workers = bworkermanager.FakeWorkerManager()
self.workers.setServiceParent(self.master)
def test_fromSsdict_patch(self):
master = fakemaster.make_master()
master.db = fakedb.FakeDBConnector(self)
master.db.insertTestData([
fakedb.Patch(id=99, subdir='/foo', patchlevel=3,
patch_base64='LS0gKys=',
patch_author='Professor Chaos',
patch_comment='comment'),
fakedb.SourceStamp(id=234, sourcestampsetid=234, branch='trunk', revision='9284',
repository='svn://...', codebase='cb', project='world-domination',
patchid=99),
])
# use getSourceStamp to minimize the risk from changes to the format of
# the ssdict
d = master.db.sourcestamps.getSourceStamp(234)
d.addCallback(lambda ssdict :
sourcestamp.SourceStamp.fromSsdict(master, ssdict))
def check(ss):
self.assertEqual(ss.ssid, 234)
self.assertEqual(ss.branch, 'trunk')
self.assertEqual(ss.revision, '9284')
self.assertEqual(ss.patch, (3, '-- ++', '/foo'))
self.assertEqual(ss.patch_info, ('Professor Chaos', 'comment'))
self.assertEqual(ss.changes, ())
self.assertEqual(ss.project, 'world-domination')
self.assertEqual(ss.repository, 'svn://...')
self.assertEqual(ss.codebase, 'cb')
d.addCallback(check)
return d
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self)
self.db = fakedb.FakeDBConnector(self)
self.db.setServiceParent(self.master)
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
def makeBuilder(self, name="bldr", patch_random=False, **config_kwargs):
"""Set up C{self.bldr}"""
self.factory = factory.BuildFactory()
self.master = fakemaster.make_master()
# only include the necessary required config, plus user-requested
config_args = dict(name=name, slavename="slv", builddir="bdir",
slavebuilddir="sbdir", factory=self.factory)
config_args.update(config_kwargs)
self.builder_config = config.BuilderConfig(**config_args)
self.bldr = builder.Builder(self.builder_config.name, _addServices=False)
self.master.db = self.db = fakedb.FakeDBConnector(self)
self.bldr.master = self.master
self.bldr.botmaster = self.master.botmaster
# patch into the _startBuildsFor method
self.builds_started = []
def _startBuildFor(slavebuilder, buildrequests):
self.builds_started.append((slavebuilder, buildrequests))
return defer.succeed(True)
self.bldr._startBuildFor = _startBuildFor
if patch_random:
# patch 'random.choice' to always take the slave that sorts
# last, based on its name
self.patch(random, "choice",
lambda lst : sorted(lst, key=lambda m : m.name)[-1])
self.bldr.startService()
mastercfg = config.MasterConfig()
mastercfg.builders = [ self.builder_config ]
return self.bldr.reconfigService(mastercfg)
def setUpRequest(self, args, options=True, activate=True):
self.request = FakeRequest(args=args)
self.request.uri = b"/change_hook/poller"
self.request.method = b"GET"
www = self.request.site.master.www
self.master = master = self.request.site.master = fakemaster.make_master(
testcase=self, wantData=True)
master.www = www
yield self.master.startService()
self.changeHook = change_hook.ChangeHookResource(
dialects={'poller': options}, master=master)
master.change_svc = ChangeManager()
yield master.change_svc.setServiceParent(master)
self.changesrc = self.Subclass(21, name='example')
yield self.changesrc.setServiceParent(master.change_svc)
self.otherpoller = self.Subclass(22, name="otherpoller")
yield self.otherpoller.setServiceParent(master.change_svc)
anotherchangesrc = base.ChangeSource(name='notapoller')
anotherchangesrc.setName(u"notapoller")
yield anotherchangesrc.setServiceParent(master.change_svc)
yield self.request.test_render(self.changeHook)
yield util.asyncSleep(0.1)
def setUp(self):
self.botmaster = mock.Mock(name='botmaster')
self.botmaster.builders = {}
self.builders = {}
def prioritizeBuilders(master, builders):
# simple sort-by-name by default
return sorted(builders, lambda b1, b2: cmp(b1.name, b2.name))
self.master = self.botmaster.master = fakemaster.make_master(testcase=self,
wantData=True, wantDb=True)
self.master.caches = fakemaster.FakeCaches()
self.master.config.prioritizeBuilders = prioritizeBuilders
self.brd = buildrequestdistributor.BuildRequestDistributor(self.botmaster)
self.brd.startService()
# TODO: this is a terrible way to detect the "end" of the test -
# it regularly completes too early after a simple modification of
# a test. Is there a better way?
self.quiet_deferred = defer.Deferred()
def _quiet():
if self.quiet_deferred:
d, self.quiet_deferred = self.quiet_deferred, None
d.callback(None)
else:
self.fail("loop has already gone quiet once")
self.brd._quiet = _quiet
# a collection of rows that would otherwise clutter up every test
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Builder(id=77, name='A'),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(sourcestampid=21, buildsetid=11),
]
def setUp(self):
self.master = fakemaster.make_master(testcase=self, wantMq=True,
wantData=True)
self.master.mq = self.master.mq
self.botmaster = BotMaster(self.master)
self.new_config = mock.Mock()
self.botmaster.startService()
def makeBuilder(self, patch_random=False, **config_kwargs):
"""Set up C{self.bldr}"""
self.bstatus = mock.Mock()
self.factory = mock.Mock()
self.master = fakemaster.make_master()
# only include the necessary required config, plus user-requested
config = dict(name="bldr", slavename="slv", builddir="bdir",
slavebuilddir="sbdir", factory=self.factory)
config.update(config_kwargs)
self.bldr = builder.Builder(config, self.bstatus)
self.master.db = self.db = db = fakedb.FakeDBConnector(self)
self.master.master_name = db.buildrequests.MASTER_NAME
self.master.master_incarnation = db.buildrequests.MASTER_INCARNATION
self.bldr.master = self.master
self.bldr.botmaster = self.master.botmaster
# patch into the _startBuildsFor method
self.builds_started = []
def _startBuildFor(slavebuilder, buildrequests):
self.builds_started.append((slavebuilder, buildrequests))
return defer.succeed(None)
self.bldr._startBuildFor = _startBuildFor
if patch_random:
# patch 'random.choice' to always take the slave that sorts
# last, based on its name
self.patch(random, "choice",
lambda lst : sorted(lst, key=lambda m : m.name)[-1])
# we don't want the reclaim service running during tests..
self.bldr.reclaim_svc.disownServiceParent()
self.bldr.startService()
def setupStep(self, *args, **kwargs):
steps.BuildStepMixin.setupStep(self, *args, **kwargs)
# This step reaches deeply into a number of parts of Buildbot. That
# should be fixed!
# set up a buildmaster that knows about two fake schedulers, a and b
self.build.builder.botmaster.parent = m = fakemaster.make_master()
self.scheduler_a = a = FakeTriggerable(name='a', builderNames=['A'])
self.scheduler_b = b = FakeTriggerable(name='b', builderNames=['B'])
def allSchedulers():
return [ a, b ]
m.allSchedulers = allSchedulers
# the build has a getSourceStamp method
def getSourceStamp():
return FakeSourceStamp(self.THIS_SSID)
self.build.getSourceStamp = getSourceStamp
# the db has a addSourceStamp method
def addSourceStamp(**kwargs):
self.addSourceStamp_kwargs = kwargs
return defer.succeed(self.NEW_SSID)
m.db.sourcestamps.addSourceStamp = addSourceStamp
self.exp_add_sourcestamp = None
self.exp_a_trigger = None
self.exp_b_trigger = None
def setUpEndpoint(self):
self.master = fakemaster.make_master(wantMq=True, wantDb=True,
wantData=True, testcase=self)
self.db = self.master.db
self.mq = self.master.mq
self.data = self.master.data
self.matcher = pathmatch.Matcher()
rtype = self.rtype = self.resourceTypeClass(self.master)
setattr(self.data.rtypes, rtype.name, rtype)
self.ep = self.endpointClass(rtype, self.master)
# this usually fails when a single-element pathPattern does not have a
# trailing comma
pathPatterns = self.ep.pathPatterns.split()
for pp in pathPatterns:
if pp == '/':
continue
if not pp.startswith('/') or pp.endswith('/'):
raise AssertionError("invalid pattern %r" % (pp,))
pathPatterns = [tuple(pp.split('/')[1:])
for pp in pathPatterns]
for pp in pathPatterns:
self.matcher[pp] = self.ep
self.pathArgs = [
set([arg.split(':', 1)[1] for arg in pp if ':' in arg])
for pp in pathPatterns if pp is not None]
def test_reconfigService_manhole(self):
master = fakemaster.make_master()
ds = debug.DebugServices()
ds.setServiceParent(master)
yield master.startService()
# start off with no manhole
yield ds.reconfigServiceWithBuildbotConfig(self.config)
# set a manhole, fire it up
self.config.manhole = manhole = FakeManhole()
yield ds.reconfigServiceWithBuildbotConfig(self.config)
self.assertTrue(manhole.running)
self.assertIdentical(manhole.master, master)
# unset it, see it stop
self.config.manhole = None
yield ds.reconfigServiceWithBuildbotConfig(self.config)
self.assertFalse(manhole.running)
self.assertIdentical(manhole.master, None)
# re-start to test stopService
self.config.manhole = manhole
yield ds.reconfigServiceWithBuildbotConfig(self.config)
# disown the service, and see that it unregisters
yield ds.disownServiceParent()
self.assertFalse(manhole.running)
self.assertIdentical(manhole.master, None)
def setupWorker(self, *args, **kwargs):
worker = dockerworker.DockerLatentWorker(*args, **kwargs)
master = fakemaster.make_master(testcase=self, wantData=True)
worker.setServiceParent(master)
self.successResultOf(master.startService())
self.addCleanup(master.stopService)
return worker
def setUp(self):
self.master = fakemaster.make_master(wantDb=True, testcase=self)
self.botmaster = FakeBotMaster(self.master)
self.clock = task.Clock()
self.patch(reactor, 'callLater', self.clock.callLater)
self.patch(reactor, 'seconds', self.clock.seconds)
def setUp(self):
# ignore config error if txrequests is not installed
self.patch(config, '_errors', Mock())
self.master = fakemaster.make_master(
testcase=self, wantData=True, wantDb=True, wantMq=True)
yield self.master.startService()
def test_fromBrdict_multiple_sourcestamps(self):
master = fakemaster.make_master()
master.db = fakedb.FakeDBConnector(self)
master.db.insertTestData([
fakedb.SourceStampSet(id=234),
fakedb.Change(changeid=13, branch='trunk', revision='9283',
repository='svn://a..', codebase='A',
project='world-domination'),
fakedb.SourceStamp(id=234, sourcestampsetid=234, branch='trunk',
revision='9283', repository='svn://a..',
codebase='A', project='world-domination'),
fakedb.SourceStampChange(sourcestampid=234, changeid=13),
fakedb.Change(changeid=14, branch='trunk', revision='9284',
repository='svn://b..', codebase='B',
project='world-domination'),
fakedb.SourceStamp(id=235, sourcestampsetid=234, branch='trunk',
revision='9284', repository='svn://b..',
codebase='B', project='world-domination'),
fakedb.SourceStampChange(sourcestampid=235, changeid=14),
fakedb.Buildset(id=539, reason='triggered', sourcestampsetid=234),
fakedb.BuildsetProperty(buildsetid=539, property_name='x',
property_value='[1, "X"]'),
fakedb.BuildsetProperty(buildsetid=539, property_name='y',
property_value='[2, "Y"]'),
fakedb.BuildRequest(id=288, buildsetid=539, buildername='bldr',
priority=13, submitted_at=1200000000),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
d = master.db.buildrequests.getBuildRequest(288)
d.addCallback(lambda brdict:
buildrequest.BuildRequest.fromBrdict(master, brdict))
def check(br):
# check enough of the source stamp to verify it found the changes
# Test the single-sourcestamp interface
self.assertEqual(br.source.ssid, 234)
# Test the multiple sourcestamp interface
self.assertEqual(br.sources['A'].ssid, 234)
self.assertEqual(br.sources['B'].ssid, 235)
self.assertEqual([ch.number for ch in br.sources['A'].changes], [13])
self.assertEqual([ch.number for ch in br.sources['B'].changes], [14])
self.assertEqual(br.reason, 'triggered')
self.assertEqual(br.properties.getProperty('x'), 1)
self.assertEqual(br.properties.getProperty('y'), 2)
self.assertEqual(br.submittedAt, 1200000000)
self.assertEqual(br.buildername, 'bldr')
self.assertEqual(br.priority, 13)
self.assertEqual(br.id, 288)
self.assertEqual(br.bsid, 539)
d.addCallback(check)
return d
def setUp(self):
self.master = master = fakemaster.make_master(
testcase=self, wantData=True)
self.botmaster = BotMaster()
self.botmaster.setServiceParent(master)
self.reactor = mock.Mock()
self.botmaster.startService()
def setUpUpgradeTest(self):
self.basedir = None
if self.source_tarball:
tarball = util.sibpath(__file__, self.source_tarball)
if not os.path.exists(tarball):
raise unittest.SkipTest(
"'%s' not found (normal when not building from Git)"
% tarball)
tf = tarfile.open(tarball)
prefixes = set()
for inf in tf:
tf.extract(inf)
prefixes.add(inf.name.split('/', 1)[0])
# (note that tf.extractall isn't available in py2.4)
# get the top-level dir from the tarball
assert len(prefixes) == 1, "tarball has multiple top-level dirs!"
self.basedir = prefixes.pop()
else:
if not os.path.exists("basedir"):
os.makedirs("basedir")
self.basedir = os.path.abspath("basedir")
master = fakemaster.make_master()
master.config.db['db_url'] = self.db_url
self.db = connector.DBConnector(master, self.basedir)
d = self.db.setup(check_version=False)
@d.addCallback
def setup_logging(_):
querylog.log_from_engine(self.db.pool.engine)
return d
def setUp(self):
self.clock = task.Clock()
self.clock.advance(SOMETIME)
self.master = fakemaster.make_master(wantDb=True, testcase=self)
self.db = self.master.db
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantDb=True)
self.db = self.master.db
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
return self.setUpTests()
def setUp(self):
self.setUpTestReactor()
self.botmaster = mock.Mock(name='botmaster')
self.botmaster.builders = {}
self.builders = {}
def prioritizeBuilders(master, builders):
# simple sort-by-name by default
return sorted(builders, key=lambda b1: b1.name)
self.master = self.botmaster.master = \
fakemaster.make_master(self, wantData=True, wantDb=True)
self.master.caches = fakemaster.FakeCaches()
self.master.config.prioritizeBuilders = prioritizeBuilders
self.brd = buildrequestdistributor.BuildRequestDistributor(
self.botmaster)
self.brd.parent = self.botmaster
self.brd.startService()
# a collection of rows that would otherwise clutter up every test
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Builder(id=77, name='A'),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(sourcestampid=21, buildsetid=11),
]
def setUp(self):
self.setUpTestReactor()
master = fakemaster.make_master(self)
self.connector = TestedWampConnector()
yield self.connector.setServiceParent(master)
yield master.startService()
yield self.connector.reconfigServiceWithBuildbotConfig(FakeConfig())
def setUp(self):
self.master = fakemaster.make_master(testcase=self, wantMq=True,
wantData=True, wantDb=True)
# set the slave port to a loopback address with unspecified
# port
self.pbmanager = self.master.pbmanager = pbmanager.PBManager()
self.pbmanager.setServiceParent(self.master)
self.buildslaves = self.master.buildslaves = bslavemanager.BuildslaveManager(self.master)
self.buildslaves.setServiceParent(self.master)
self.botmaster = botmaster.BotMaster(self.master)
self.botmaster.setServiceParent(self.master)
self.master.status = master.Status(self.master)
self.master.botmaster = self.botmaster
self.master.data.updates.buildslaveConfigured = lambda *a, **k: None
yield self.master.startService()
self.buildslave = None
self.port = None
self.slavebuildslave = None
self.connector = None
self._detach_deferreds = []
# patch in our FakeBuilder for the regular Builder class
self.patch(botmaster, 'Builder', FakeBuilder)
def setUp(self):
self.clock = task.Clock()
self.clock.advance(SOMETIME)
self.master = fakemaster.make_master()
self.db = fakedb.FakeDBConnector(self.master, self)
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantData=True, wantDb=True)
self.master.botmaster = mock.Mock(name='botmaster')
self.master.botmaster.builders = {}
self.builders = {}
self.bldr = yield self.createBuilder('A', builderid=77)
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantData=True)
self.cm = manager.ChangeManager()
self.master.startService()
self.cm.setServiceParent(self.master)
self.new_config = mock.Mock()
def setUp(self):
self.master = fakemaster.make_master(wantDb=True,
wantData=True,
testcase=self)
self.botmaster = self.master.botmaster
self.workers = self.master.workers
def make_dbc(_):
master = fakemaster.make_master()
self.db = connector.DBConnector(master, self.basedir)
return self.db.setup(check_version=False)
def setUp(self):
self.setup_test_reactor()
self.master = fakemaster.make_master(self)
self.wrk = worker.FakeWorker(self.master)
def __init__(self, user):
self.user = user
self.master = fakemaster.make_master(wantDb=True, testcase=self)
def setUp(self):
self.master = fakemaster.make_master(testcase=self)
self.sl = worker.FakeWorker(self.master)
def test_canBeCollapsed_different_codebases_raises_error(self):
""" This testcase has two buildrequests
Request Change Codebase Revision Comment
----------------------------------------------------------------------
288 17 C 1800 request 1 has repo not in request 2
289 18 D 2100 request 2 has repo not in request 1
--------------------------------
Merge cannot be performd and raises error:
Merging requests requires both requests to have the same codebases
"""
brDicts = [] # list of buildrequests dictionnary
master = fakemaster.make_master(testcase=self,
wantData=True,
wantDb=True)
master.db.insertTestData([
fakedb.Builder(id=77, name='bldr'),
fakedb.SourceStamp(id=238,
branch='trunk',
revision='1800',
repository='svn://c..',
codebase='C',
project='world-domination'),
fakedb.Change(changeid=17,
branch='trunk',
revision='1800',
repository='svn://c..',
codebase='C',
project='world-domination',
sourcestampid=238),
fakedb.SourceStamp(id=239,
branch='trunk',
revision='2100',
repository='svn://d..',
codebase='D',
project='world-domination'),
fakedb.Change(changeid=18,
branch='trunk',
revision='2100',
repository='svn://d..',
codebase='D',
project='world-domination',
sourcestampid=239),
fakedb.Buildset(id=539, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=238),
fakedb.BuildRequest(id=288, buildsetid=539, builderid=77),
fakedb.Buildset(id=540, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=540, sourcestampid=239),
fakedb.BuildRequest(id=289, buildsetid=540, builderid=77),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
d = master.db.buildrequests.getBuildRequest(288)
d.addCallback(lambda brdict: brDicts.append(brdict))
d.addCallback(lambda _: master.db.buildrequests.getBuildRequest(289))
d.addCallback(lambda brdict: brDicts.append(brdict))
d.addCallback(lambda _: buildrequest.BuildRequest.canBeCollapsed(
master, brDicts[0], brDicts[1]))
def check(canBeCollapsed):
self.assertEqual(canBeCollapsed, False)
d.addCallback(check)
return d
def test_mergeSourceStampsWith_common_codebases(self):
""" This testcase has two buildrequests
Request Change Codebase Revision Comment
----------------------------------------------------------------------
288 13 A 9283
289 15 A 9284
288 14 B 9200
289 16 B 9201
--------------------------------
After merged in Build:
Source1 has rev 9284 and contains changes 13 and 15 from repository svn://a
Source2 has rev 9201 and contains changes 14 and 16 from repository svn://b
"""
brs = [] # list of buildrequests
master = fakemaster.make_master(testcase=self,
wantData=True,
wantDb=True)
master.db.insertTestData([
fakedb.Builder(id=77, name='bldr'),
fakedb.SourceStamp(id=234,
branch='trunk',
revision='9283',
repository='svn://a..',
codebase='A',
project='world-domination'),
fakedb.Change(changeid=13,
branch='trunk',
revision='9283',
repository='svn://a..',
codebase='A',
project='world-domination',
sourcestampid=234),
fakedb.SourceStamp(id=235,
branch='trunk',
revision='9200',
repository='svn://b..',
codebase='B',
project='world-domination'),
fakedb.Change(changeid=14,
branch='trunk',
revision='9200',
repository='svn://b..',
codebase='A',
project='world-domination',
sourcestampid=235),
fakedb.SourceStamp(id=236,
branch='trunk',
revision='9284',
repository='svn://a..',
codebase='A',
project='world-domination'),
fakedb.Change(changeid=15,
branch='trunk',
revision='9284',
repository='svn://a..',
codebase='A',
project='world-domination',
sourcestampid=236),
fakedb.SourceStamp(id=237,
branch='trunk',
revision='9201',
repository='svn://b..',
codebase='B',
project='world-domination'),
fakedb.Change(changeid=16,
branch='trunk',
revision='9201',
repository='svn://b..',
codebase='B',
project='world-domination',
sourcestampid=237),
fakedb.Buildset(id=539, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=234),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=235),
fakedb.BuildRequest(id=288, buildsetid=539, builderid=77),
fakedb.Buildset(id=540, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=540, sourcestampid=236),
fakedb.BuildsetSourceStamp(buildsetid=540, sourcestampid=237),
fakedb.BuildRequest(id=289, buildsetid=540, builderid=77),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
d = master.db.buildrequests.getBuildRequest(288)
d.addCallback(lambda brdict: buildrequest.BuildRequest.fromBrdict(
master, brdict))
d.addCallback(lambda br: brs.append(br))
d.addCallback(lambda _: master.db.buildrequests.getBuildRequest(289))
d.addCallback(lambda brdict: buildrequest.BuildRequest.fromBrdict(
master, brdict))
d.addCallback(lambda br: brs.append(br))
def check(_):
sources = brs[0].mergeSourceStampsWith(brs[1:])
source1 = source2 = None
for source in sources:
if source.codebase == 'A':
source1 = source
if source.codebase == 'B':
source2 = source
self.assertFalse(source1 is None)
self.assertEqual(source1.revision, '9284')
self.assertFalse(source2 is None)
self.assertEqual(source2.revision, '9201')
d.addCallback(check)
return d
def test_fromBrdict_multiple_sourcestamps(self):
master = fakemaster.make_master(testcase=self,
wantData=True,
wantDb=True)
master.db.insertTestData([
fakedb.Builder(id=77, name='bldr'),
fakedb.SourceStamp(id=234,
branch='trunk',
revision='9283',
repository='svn://a..',
codebase='A',
project='world-domination'),
fakedb.Change(changeid=13,
branch='trunk',
revision='9283',
repository='svn://a..',
codebase='A',
project='world-domination',
sourcestampid=234),
fakedb.SourceStamp(id=235,
branch='trunk',
revision='9284',
repository='svn://b..',
codebase='B',
project='world-domination'),
fakedb.Change(changeid=14,
branch='trunk',
revision='9284',
repository='svn://b..',
codebase='B',
project='world-domination',
sourcestampid=235),
fakedb.Buildset(id=539, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=234),
fakedb.BuildsetProperty(buildsetid=539,
property_name='x',
property_value='[1, "X"]'),
fakedb.BuildsetProperty(buildsetid=539,
property_name='y',
property_value='[2, "Y"]'),
fakedb.BuildRequest(id=288,
buildsetid=539,
builderid=77,
priority=13,
submitted_at=1200000000),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
d = master.db.buildrequests.getBuildRequest(288)
d.addCallback(lambda brdict: buildrequest.BuildRequest.fromBrdict(
master, brdict))
def check(br):
self.assertEqual(br.reason, 'triggered')
self.assertEqual(br.properties.getProperty('x'), 1)
self.assertEqual(br.properties.getProperty('y'), 2)
self.assertEqual(br.submittedAt, 1200000000)
self.assertEqual(br.buildername, 'bldr')
self.assertEqual(br.priority, 13)
self.assertEqual(br.id, 288)
self.assertEqual(br.bsid, 539)
d.addCallback(check)
return d
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(self, wantData=wantData,
wantDb=wantDb, wantMq=wantMq)
# 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)
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)
# 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 test_constructor(self):
self.setUpTestReactor()
master = fakemaster.make_master(self)
listener = base.Listener()
yield listener.setServiceParent(master)
self.assertEqual(listener.master, master)
def setUp(self):
self.master = fakemaster.make_master()
self.mqconfig = self.master.config.mq = {}
self.conn = connector.MQConnector()
self.conn.setServiceParent(self.master)
def setUp(self):
self.master = fakemaster.make_master()
self.db = fakedb.FakeDBConnector(self)
self.db.setServiceParent(self.master)
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
def setUp(self):
self.master = fakemaster.make_master(testcase=self,
wantDb=True, wantData=True)
def setUp(self):
self.master = fakemaster.make_master()
self.botmaster = BotMaster(self.master)
self.new_config = mock.Mock()
self.botmaster.startService()
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantDb=True, wantData=True)
self.db = self.master.db
self.object = FakeObject(self.master, self.codebases)
def setUp(self):
self.master = fakemaster.make_master(wantDb=True, testcase=self)
self.db = self.master.db
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantDb=True, wantData=True)
self.botmaster = self.master.botmaster
self.workers = self.master.workers
def setUp(self):
self.master = fakemaster.make_master()
self.master.wamp = FakeWampConnector()
self.mq = wamp.WampMQ()
self.mq.setServiceParent(self.master)
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantDb=True)
self.object = FakeObject(self.master)
def run_prepare_gsp(self, gsp):
gsp.master = fakemaster.make_master()
gsp.master_status = gsp.master.status
def setUp(self):
self.master = fakemaster.make_master(testcase=self, wantMq=True)
self.data = connector.DataConnector()
self.data.setServiceParent(self.master)
def setUp(self):
self.master = fakemaster.make_master()
# don't load by default
self.patch(connector.DataConnector, 'submodules', [])
self.data = connector.DataConnector()
self.data.setServiceParent(self.master)
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self, wantMq=True)
self.mq = self.master.mq
self.mq.verifyMessages = False
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self)
self.mq = simple.SimpleMQ()
self.mq.setServiceParent(self.master)
def setUp(self):
table_names = [
'objects', 'object_state', 'masters',
'workers', 'configured_workers', 'connected_workers',
'builder_masters', 'builders'
]
master = fakemaster.make_master(self, wantRealReactor=True)
yield self.setUpRealDatabaseWithConnector(master, table_names=table_names,
sqlite_memory=False)
master.data = dataconnector.DataConnector()
yield master.data.setServiceParent(master)
master.config.mq = dict(type='simple')
master.mq = mqconnector.MQConnector()
yield master.mq.setServiceParent(master)
yield master.mq.setup()
yield master.mq.startService()
master.config.www = dict(
port='tcp:0:interface=127.0.0.1',
debug=True,
auth=auth.NoAuth(),
authz=authz.Authz(),
avatar_methods=[],
logfileName='http.log')
master.www = wwwservice.WWWService()
yield master.www.setServiceParent(master)
yield master.www.startService()
yield master.www.reconfigServiceWithBuildbotConfig(master.config)
session = mock.Mock()
session.uid = "0"
master.www.site.sessionFactory = mock.Mock(return_value=session)
# now that we have a port, construct the real URL and insert it into
# the config. The second reconfig isn't really required, but doesn't
# hurt.
self.url = 'http://127.0.0.1:%d/' % master.www.getPortnum()
self.url = unicode2bytes(self.url)
master.config.buildbotURL = self.url
yield master.www.reconfigServiceWithBuildbotConfig(master.config)
self.master = master
self.agent = client.Agent(reactor)
# create a telegram bot service
tb = master.config.services['TelegramBot'] = telegram.TelegramBot(
bot_token='12345:secret', useWebhook=True,
chat_ids=[-123456], notify_events=['worker']
)
tb._get_http = self.get_http
yield tb.setServiceParent(self.master)
self.bot_url = self.url + b"telegram12345:secret"
yield tb.startService()
self.sent_messages = []
def send_message(chat, message, **kwargs):
self.sent_messages.append((chat, message))
tb.bot.send_message = send_message
def setUp(self):
self.master = fakemaster.make_master(testcase=self)
def setUp(self):
self.master = fakemaster.make_master(testcase=self)
self.createKube()
self.kube.setServiceParent(self.master)
return self.master.startService()
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self,
wantData=True,
wantDb=True,
wantMq=True)
def setUp(self):
self.master = fakemaster.make_master(wantMq=True,
wantDb=True,
wantData=True,
testcase=self)
self.rtype = schedulers.Scheduler(self.master)
def make_dbc(_):
master = fakemaster.make_master()
master.config.db['db_url'] = self.db_url
self.db = DBConnector(master, self.basedir)
return self.db.setup(check_version=False)
