id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
4,400 | test_filter.py | buildbot_buildbot/master/buildbot/test/unit/changes/test_filter.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import re
from parameterized import parameterized
from twisted.trial import unittest
from buildbot.changes.filter import ChangeFilter
from buildbot.test.fake.change import Change
class TestChangeFilter(unittest.TestCase):
def test_filter_change_filter_fn(self):
f = ChangeFilter(filter_fn=lambda ch: ch.x > 3)
self.assertFalse(f.filter_change(Change(x=2)))
self.assertTrue(f.filter_change(Change(x=4)))
self.assertEqual(repr(f), "<ChangeFilter on <lambda>()>")
test_cases = [
(
"match",
Change(project="p", codebase="c", repository="r", category="ct", branch="b"),
True,
),
(
"not_project",
Change(project="p0", codebase="c", repository="r", category="ct", branch="b"),
False,
),
(
"not_codebase",
Change(project="p", codebase="c0", repository="r", category="ct", branch="b"),
False,
),
(
"not_repository",
Change(project="p", codebase="c", repository="r0", category="ct", branch="b"),
False,
),
(
"not_category",
Change(project="p", codebase="c", repository="r", category="ct0", branch="b"),
False,
),
(
"not_branch",
Change(project="p", codebase="c", repository="r", category="ct", branch="b0"),
False,
),
]
@parameterized.expand(test_cases)
def test_eq(self, name, change, expected):
f = ChangeFilter(project="p", codebase="c", repository="r", category="ct", branch="b")
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_eq_list(self, name, change, expected):
f = ChangeFilter(
project=["p", "p9"],
codebase=["c", "c9"],
repository=["r", "r9"],
category=["ct", "ct9"],
branch=["b", "b9"],
)
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_not_eq(self, name, change, expected):
f = ChangeFilter(
project_not_eq="p0",
codebase_not_eq="c0",
repository_not_eq="r0",
category_not_eq="ct0",
branch_not_eq="b0",
)
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_not_eq_list(self, name, change, expected):
f = ChangeFilter(
project_not_eq=["p0", "p1"],
codebase_not_eq=["c0", "c1"],
repository_not_eq=["r0", "r1"],
category_not_eq=["ct0", "ct1"],
branch_not_eq=["b0", "b1"],
)
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_re(self, name, change, expected):
f = ChangeFilter(
project_re="^p$",
codebase_re="^c$",
repository_re="^r$",
category_re="^ct$",
branch_re="^b$",
)
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_re_list(self, name, change, expected):
f = ChangeFilter(
project_re=["^p$", "^p1$"],
codebase_re=["^c$", "^c1$"],
repository_re=["^r$", "^r1$"],
category_re=["^ct$", "^ct1$"],
branch_re=["^b$", "^b1$"],
)
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_not_re(self, name, change, expected):
f = ChangeFilter(
project_not_re="^p0$",
codebase_not_re="^c0$",
repository_not_re="^r0$",
category_not_re="^ct0$",
branch_not_re="^b0$",
)
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_not_re_list(self, name, change, expected):
f = ChangeFilter(
project_not_re=["^p0$", "^p1$"],
codebase_not_re=["^c0$", "^c1$"],
repository_not_re=["^r0$", "^r1$"],
category_not_re=["^ct0$", "^ct1$"],
branch_not_re=["^b0$", "^b1$"],
)
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_re_pattern(self, name, change, expected):
f = ChangeFilter(
project_re=re.compile("^p$"),
codebase_re=re.compile("^c$"),
repository_re=re.compile("^r$"),
category_re=re.compile("^ct$"),
branch_re=re.compile("^b$"),
)
self.assertEqual(f.filter_change(change), expected)
@parameterized.expand(test_cases)
def test_fn(self, name, change, expected):
f = ChangeFilter(
project_fn=lambda p: p == "p",
codebase_fn=lambda p: p == "c",
repository_fn=lambda p: p == "r",
category_fn=lambda p: p == "ct",
branch_fn=lambda p: p == "b",
)
self.assertEqual(f.filter_change(change), expected)
self.assertEqual(
repr(f),
"<ChangeFilter on <lambda>(project) and <lambda>(codebase) and "
"<lambda>(repository) and <lambda>(category) and <lambda>(branch)>",
)
def test_filter_change_filt_branch_list_None(self):
f = ChangeFilter(branch=["mybr", None])
self.assertTrue(f.filter_change(Change(branch="mybr")))
self.assertTrue(f.filter_change(Change(branch=None)))
self.assertFalse(f.filter_change(Change(branch="misc")))
def test_filter_change_branch_re(self): # regression - see #927
f = ChangeFilter(branch_re="^t.*")
self.assertTrue(f.filter_change(Change(branch="trunk")))
self.assertFalse(f.filter_change(Change(branch="development")))
self.assertFalse(f.filter_change(Change(branch=None)))
def test_filter_change_combination(self):
f = ChangeFilter(project="p", repository="r", branch="b", category="c", codebase="cb")
self.assertFalse(
f.filter_change(Change(project="x", repository="x", branch="x", category="x"))
)
self.assertFalse(
f.filter_change(Change(project="p", repository="r", branch="b", category="x"))
)
self.assertFalse(
f.filter_change(Change(project="p", repository="r", branch="b", category="c"))
)
self.assertTrue(
f.filter_change(
Change(project="p", repository="r", branch="b", category="c", codebase="cb")
)
)
def test_filter_change_combination_filter_fn(self):
f = ChangeFilter(
project="p",
repository="r",
branch="b",
category="c",
filter_fn=lambda c: c.ff,
)
self.assertFalse(
f.filter_change(Change(project="x", repository="x", branch="x", category="x", ff=False))
)
self.assertFalse(
f.filter_change(Change(project="p", repository="r", branch="b", category="c", ff=False))
)
self.assertFalse(
f.filter_change(Change(project="x", repository="x", branch="x", category="x", ff=True))
)
self.assertTrue(
f.filter_change(Change(project="p", repository="r", branch="b", category="c", ff=True))
)
def test_filter_props(self):
f = ChangeFilter(property_eq={"event.type": "ref-updated"})
self.assertTrue(f.filter_change(Change(properties={"event.type": "ref-updated"})))
self.assertFalse(f.filter_change(Change(properties={"event.type": "patch-uploaded"})))
self.assertFalse(f.filter_change(Change(properties={})))
f = ChangeFilter(property_re={"event.type": "^ref-updated$"})
self.assertTrue(f.filter_change(Change(properties={"event.type": "ref-updated"})))
self.assertFalse(f.filter_change(Change(properties={"event.type": "patch-uploaded"})))
self.assertFalse(f.filter_change(Change(properties={})))
| 8,833 | Python | .py | 211 | 32.483412 | 100 | 0.580484 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,401 | test_changes.py | buildbot_buildbot/master/buildbot/test/unit/changes/test_changes.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import pprint
import re
import textwrap
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.changes import changes
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
class Change(unittest.TestCase, TestReactorMixin):
change23_rows = [
fakedb.Change(
changeid=23,
author="dustin",
committer="dustin",
comments="fix whitespace",
branch="warnerdb",
revision="deadbeef",
when_timestamp=266738404,
revlink='http://warner/0e92a098b',
category='devel',
repository='git://warner',
codebase='mainapp',
project='Buildbot',
),
fakedb.ChangeFile(changeid=23, filename='master/README.txt'),
fakedb.ChangeFile(changeid=23, filename='worker/README.txt'),
fakedb.ChangeProperty(
changeid=23, property_name='notest', property_value='["no","Change"]'
),
fakedb.ChangeUser(changeid=23, uid=27),
]
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantDb=True)
self.change23 = changes.Change(**{ # using **dict(..) forces kwargs
"category": 'devel',
"repository": 'git://warner',
"codebase": 'mainapp',
"who": 'dustin',
"committer": 'dustin',
"when": 266738404,
"comments": 'fix whitespace',
"project": 'Buildbot',
"branch": 'warnerdb',
"revlink": 'http://warner/0e92a098b',
"properties": {'notest': "no"},
"files": ['master/README.txt', 'worker/README.txt'],
"revision": 'deadbeef',
})
self.change23.number = 23
self.change24 = changes.Change(**{
"category": 'devel',
"repository": 'git://warner',
"codebase": 'mainapp',
"who": 'dustin',
"committer": 'dustin',
"when": 266738405,
"comments": 'fix whitespace again',
"project": 'Buildbot',
"branch": 'warnerdb',
"revlink": 'http://warner/0e92a098c',
"properties": {'notest': "no"},
"files": ['master/README.txt', 'worker/README.txt'],
"revision": 'deadbeef',
})
self.change24.number = 24
self.change25 = changes.Change(**{
"category": 'devel',
"repository": 'git://warner',
"codebase": 'mainapp',
"who": 'dustin',
"committer": 'dustin',
"when": 266738406,
"comments": 'fix whitespace again',
"project": 'Buildbot',
"branch": 'warnerdb',
"revlink": 'http://warner/0e92a098d',
"properties": {'notest': "no"},
"files": ['master/README.txt', 'worker/README.txt'],
"revision": 'deadbeef',
})
self.change25.number = 25
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_fromChdict(self):
# get a real honest-to-goodness chdict from the fake db
yield self.master.db.insert_test_data(self.change23_rows)
chdict = yield self.master.db.changes.getChange(23)
exp = self.change23
got = yield changes.Change.fromChdict(self.master, chdict)
# compare
ok = True
ok = ok and got.number == exp.number
ok = ok and got.who == exp.who
ok = ok and got.committer == exp.committer
ok = ok and sorted(got.files) == sorted(exp.files)
ok = ok and got.comments == exp.comments
ok = ok and got.revision == exp.revision
ok = ok and got.when == exp.when
ok = ok and got.branch == exp.branch
ok = ok and got.category == exp.category
ok = ok and got.revlink == exp.revlink
ok = ok and got.properties == exp.properties
ok = ok and got.repository == exp.repository
ok = ok and got.codebase == exp.codebase
ok = ok and got.project == exp.project
if not ok:
def printable(c):
return pprint.pformat(c.__dict__)
self.fail(f"changes do not match; expected\n{printable(exp)}\ngot\n{printable(got)}")
def test_str(self):
string = str(self.change23)
self.assertTrue(re.match(r"Change\(.*\)", string), string)
def test_asText(self):
text = self.change23.asText()
self.assertTrue(
re.match(
textwrap.dedent("""\
Files:
master/README.txt
worker/README.txt
On: git://warner
For: Buildbot
At: .*
Changed By: dustin
Committed By: dustin
Comments: fix whitespaceProperties:.
notest: no
"""),
text,
),
text,
)
def test_asDict(self):
dict = self.change23.asDict()
self.assertIn('1978', dict['at']) # timezone-sensitive
del dict['at']
self.assertEqual(
dict,
{
'branch': 'warnerdb',
'category': 'devel',
'codebase': 'mainapp',
'comments': 'fix whitespace',
'files': [{'name': 'master/README.txt'}, {'name': 'worker/README.txt'}],
'number': 23,
'project': 'Buildbot',
'properties': [('notest', 'no', 'Change')],
'repository': 'git://warner',
'rev': 'deadbeef',
'revision': 'deadbeef',
'revlink': 'http://warner/0e92a098b',
'when': 266738404,
'who': 'dustin',
'committer': 'dustin',
},
)
def test_getShortAuthor(self):
self.assertEqual(self.change23.getShortAuthor(), 'dustin')
def test_getTime(self):
# careful, or timezones will hurt here
self.assertIn('Jun 1978', self.change23.getTime())
def test_getTimes(self):
self.assertEqual(self.change23.getTimes(), (266738404, None))
def test_getText(self):
self.change23.who = 'nasty < nasty' # test the html escaping (ugh!)
self.assertEqual(self.change23.getText(), ['nasty < nasty'])
def test_getLogs(self):
self.assertEqual(self.change23.getLogs(), {})
def test_compare(self):
self.assertEqual(self.change23, self.change23)
self.assertNotEqual(self.change24, self.change23)
self.assertGreater(self.change24, self.change23)
self.assertGreaterEqual(self.change24, self.change23)
self.assertGreaterEqual(self.change24, self.change24)
self.assertLessEqual(self.change24, self.change24)
self.assertLessEqual(self.change23, self.change24)
self.assertLess(self.change23, self.change25)
| 7,831 | Python | .py | 196 | 29.954082 | 97 | 0.581133 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,402 | test_connector.py | buildbot_buildbot/master/buildbot/test/unit/db/test_connector.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import os
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.config.master import MasterConfig
from buildbot.db import connector
from buildbot.db import exceptions
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util import db
class TestDBConnector(TestReactorMixin, db.RealDatabaseMixin, unittest.TestCase):
"""
Basic tests of the DBConnector class - all start with an empty DB
"""
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setUpRealDatabase(
table_names=[
'changes',
'change_properties',
'change_files',
'patches',
'sourcestamps',
'buildset_properties',
'buildsets',
'sourcestampsets',
'builds',
'builders',
'masters',
'buildrequests',
'workers',
"projects",
]
)
self.master = yield fakemaster.make_master(self)
self.master.config = MasterConfig()
self.db = connector.DBConnector(os.path.abspath('basedir'))
yield self.db.setServiceParent(self.master)
@defer.inlineCallbacks
def tearDown(self):
if self.db.running:
yield self.db.stopService()
yield self.tearDownRealDatabase()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def startService(self, check_version=False):
self.master.config.db['db_url'] = self.db_url
yield self.db.setup(check_version=check_version)
self.db.startService()
yield self.db.reconfigServiceWithBuildbotConfig(self.master.config)
# tests
@defer.inlineCallbacks
def test_doCleanup_service(self):
yield self.startService()
self.assertTrue(self.db.cleanup_timer.running)
def test_doCleanup_unconfigured(self):
self.db.changes.pruneChanges = mock.Mock(return_value=defer.succeed(None))
self.db._doCleanup()
self.assertFalse(self.db.changes.pruneChanges.called)
@defer.inlineCallbacks
def test_doCleanup_configured(self):
self.db.changes.pruneChanges = mock.Mock(return_value=defer.succeed(None))
yield self.startService()
self.db._doCleanup()
self.assertTrue(self.db.changes.pruneChanges.called)
def test_setup_check_version_bad(self):
if self.db_url == 'sqlite://':
raise unittest.SkipTest('sqlite in-memory model is always upgraded at connection')
d = self.startService(check_version=True)
return self.assertFailure(d, exceptions.DatabaseNotReadyError)
def test_setup_check_version_good(self):
self.db.model.is_current = lambda: defer.succeed(True)
return self.startService(check_version=True)
| 3,695 | Python | .py | 88 | 34.386364 | 94 | 0.689136 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,403 | test_steps.py | buildbot_buildbot/master/buildbot/test/unit/db/test_steps.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import time
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import steps
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
from buildbot.util import epoch2datetime
TIME1 = 1304262222
TIME2 = 1304262223
TIME3 = 1304262224
TIME4 = 1304262235
TIME5 = 1304262236
class Tests(interfaces.InterfaceTests):
# common sample data
backgroundData = [
fakedb.Worker(id=47, name='linux'),
fakedb.Buildset(id=20),
fakedb.Builder(id=88, name='b1'),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=88),
fakedb.Master(id=88),
fakedb.Build(id=30, buildrequestid=41, number=7, masterid=88, builderid=88, workerid=47),
fakedb.Build(id=31, buildrequestid=41, number=8, masterid=88, builderid=88, workerid=47),
]
stepRows = [
fakedb.Step(
id=70,
number=0,
name='one',
buildid=30,
started_at=TIME1,
locks_acquired_at=TIME2,
complete_at=TIME3,
state_string='test',
results=0,
),
fakedb.Step(
id=71,
number=1,
name='two',
buildid=30,
started_at=TIME2,
locks_acquired_at=TIME3,
complete_at=TIME4,
state_string='test',
results=2,
urls_json='[{"name": "url", "url": "http://url"}]',
hidden=1,
),
fakedb.Step(id=72, number=2, name='three', buildid=30, started_at=TIME5),
fakedb.Step(id=73, number=0, name='wrong-build', buildid=31),
]
stepDicts = [
steps.StepModel(
id=70,
buildid=30,
number=0,
name='one',
results=0,
started_at=epoch2datetime(TIME1),
locks_acquired_at=epoch2datetime(TIME2),
complete_at=epoch2datetime(TIME3),
state_string='test',
urls=[],
hidden=False,
),
steps.StepModel(
id=71,
buildid=30,
number=1,
name='two',
results=2,
started_at=epoch2datetime(TIME2),
locks_acquired_at=epoch2datetime(TIME3),
complete_at=epoch2datetime(TIME4),
state_string='test',
urls=[steps.UrlModel(name='url', url='http://url')],
hidden=True,
),
steps.StepModel(
id=72,
buildid=30,
number=2,
name='three',
results=None,
started_at=epoch2datetime(TIME5),
locks_acquired_at=None,
complete_at=None,
state_string='',
urls=[],
hidden=False,
),
]
# signature tests
def test_signature_getStep(self):
@self.assertArgSpecMatches(self.db.steps.getStep)
def getStep(self, stepid=None, buildid=None, number=None, name=None):
pass
def test_signature_getSteps(self):
@self.assertArgSpecMatches(self.db.steps.getSteps)
def getSteps(self, buildid):
pass
def test_signature_addStep(self):
@self.assertArgSpecMatches(self.db.steps.addStep)
def addStep(self, buildid, name, state_string):
pass
def test_signature_startStep(self):
@self.assertArgSpecMatches(self.db.steps.startStep)
def addStep(self, stepid, started_at, locks_acquired):
pass
def test_signature_setStepStateString(self):
@self.assertArgSpecMatches(self.db.steps.setStepStateString)
def setStepStateString(self, stepid, state_string):
pass
def test_signature_finishStep(self):
@self.assertArgSpecMatches(self.db.steps.finishStep)
def finishStep(self, stepid, results, hidden):
pass
# method tests
@defer.inlineCallbacks
def test_getStep(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[0]])
stepdict = yield self.db.steps.getStep(70)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(stepdict, self.stepDicts[0])
@defer.inlineCallbacks
def test_getStep_missing(self):
stepdict = yield self.db.steps.getStep(50)
self.assertEqual(stepdict, None)
@defer.inlineCallbacks
def test_getStep_number(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[1]])
stepdict = yield self.db.steps.getStep(buildid=30, number=1)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(stepdict.id, 71)
@defer.inlineCallbacks
def test_getStep_number_missing(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[1]])
stepdict = yield self.db.steps.getStep(buildid=30, number=9)
self.assertEqual(stepdict, None)
@defer.inlineCallbacks
def test_getStep_name(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[2]])
stepdict = yield self.db.steps.getStep(buildid=30, name='three')
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(stepdict.id, 72)
@defer.inlineCallbacks
def test_getStep_name_missing(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[2]])
stepdict = yield self.db.steps.getStep(buildid=30, name='five')
self.assertEqual(stepdict, None)
@defer.inlineCallbacks
def test_getStep_invalid(self):
d = self.db.steps.getStep(buildid=30)
yield self.assertFailure(d, RuntimeError)
@defer.inlineCallbacks
def test_getSteps(self):
yield self.insert_test_data(self.backgroundData + self.stepRows)
stepdicts = yield self.db.steps.getSteps(buildid=30)
for stepdict in stepdicts:
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(stepdicts, self.stepDicts[:3])
@defer.inlineCallbacks
def test_getSteps_none(self):
yield self.insert_test_data(self.backgroundData + self.stepRows)
stepdicts = yield self.db.steps.getSteps(buildid=33)
self.assertEqual(stepdicts, [])
@defer.inlineCallbacks
def test_addStep_getStep(self):
yield self.insert_test_data(self.backgroundData)
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='new', state_string='new'
)
yield self.db.steps.startStep(stepid=stepid, started_at=TIME1, locks_acquired=False)
self.assertEqual((number, name), (0, 'new'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(
stepdict,
steps.StepModel(
id=stepid,
buildid=30,
name='new',
number=0,
started_at=epoch2datetime(TIME1),
locks_acquired_at=None,
complete_at=None,
results=None,
state_string='new',
urls=[],
hidden=False,
),
)
@defer.inlineCallbacks
def test_addStep_getStep_locks_acquired_already(self):
yield self.insert_test_data(self.backgroundData)
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='new', state_string='new'
)
yield self.db.steps.startStep(stepid=stepid, started_at=TIME1, locks_acquired=True)
self.assertEqual((number, name), (0, 'new'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(
stepdict,
steps.StepModel(
id=stepid,
buildid=30,
name="new",
number=0,
started_at=epoch2datetime(TIME1),
locks_acquired_at=epoch2datetime(TIME1),
complete_at=None,
results=None,
state_string="new",
urls=[],
hidden=False,
),
)
@defer.inlineCallbacks
def test_addStep_getStep_locks_acquired_later(self):
yield self.insert_test_data(self.backgroundData)
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='new', state_string='new'
)
yield self.db.steps.startStep(stepid=stepid, started_at=TIME1, locks_acquired=False)
yield self.db.steps.set_step_locks_acquired_at(stepid=stepid, locks_acquired_at=TIME2)
self.assertEqual((number, name), (0, 'new'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(
stepdict,
steps.StepModel(
id=stepid,
buildid=30,
name='new',
number=0,
started_at=epoch2datetime(TIME1),
locks_acquired_at=epoch2datetime(TIME2),
complete_at=None,
results=None,
state_string='new',
urls=[],
hidden=False,
),
)
@defer.inlineCallbacks
def test_addStep_getStep_existing_step(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[0]])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='new', state_string='new'
)
yield self.db.steps.startStep(stepid=stepid, started_at=TIME1, locks_acquired=False)
self.assertEqual((number, name), (1, 'new'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(stepdict.number, number)
self.assertEqual(stepdict.name, name)
@defer.inlineCallbacks
def test_addStep_getStep_name_collisions(self):
yield self.insert_test_data([
*self.backgroundData,
fakedb.Step(id=73, number=0, name='new', buildid=30),
fakedb.Step(id=74, number=1, name='new_1', buildid=30),
fakedb.Step(id=75, number=2, name='new_2', buildid=30),
fakedb.Step(id=76, number=3, name='new_step', buildid=30),
])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='new', state_string='new'
)
yield self.db.steps.startStep(stepid=stepid, started_at=TIME1, locks_acquired=False)
self.assertEqual((number, name), (4, 'new_3'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(stepdict.number, number)
self.assertEqual(stepdict.name, name)
@defer.inlineCallbacks
def test_setStepStateString(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[2]])
yield self.db.steps.setStepStateString(stepid=72, state_string='aaa')
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict.state_string, 'aaa')
@defer.inlineCallbacks
def test_addURL(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[2]])
yield self.db.steps.addURL(stepid=72, name='foo', url='bar')
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict.urls, [steps.UrlModel(name='foo', url='bar')])
@defer.inlineCallbacks
def test_addURL_race(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[2]])
yield defer.gatherResults([
# only a tiny sleep is required to see the problem.
self.db.steps.addURL(
stepid=72, name='foo', url='bar', _racehook=lambda: time.sleep(0.01)
),
self.db.steps.addURL(stepid=72, name='foo2', url='bar2'),
])
stepdict = yield self.db.steps.getStep(stepid=72)
def urlKey(url):
return url.name
# order is not guaranteed though
self.assertEqual(
sorted(stepdict.urls, key=urlKey),
sorted(
[steps.UrlModel(name='foo', url='bar'), steps.UrlModel(name='foo2', url='bar2')],
key=urlKey,
),
)
@defer.inlineCallbacks
def test_addURL_no_duplicate(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[2]])
yield defer.gatherResults([
self.db.steps.addURL(stepid=72, name='foo', url='bar'),
self.db.steps.addURL(stepid=72, name='foo', url='bar'),
])
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict.urls, [steps.UrlModel(name='foo', url='bar')])
@defer.inlineCallbacks
def test_finishStep(self):
self.reactor.advance(TIME2)
yield self.insert_test_data([*self.backgroundData, self.stepRows[2]])
yield self.db.steps.finishStep(stepid=72, results=11, hidden=False)
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict.results, 11)
self.assertEqual(stepdict.complete_at, epoch2datetime(TIME2))
self.assertEqual(stepdict.hidden, False)
@defer.inlineCallbacks
def test_finishStep_hidden(self):
yield self.insert_test_data([*self.backgroundData, self.stepRows[2]])
yield self.db.steps.finishStep(stepid=72, results=11, hidden=True)
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict.hidden, True)
class RealTests(Tests):
# the fake connector doesn't deal with this edge case
@defer.inlineCallbacks
def test_addStep_getStep_name_collisions_too_long(self):
yield self.insert_test_data([
*self.backgroundData,
fakedb.Step(id=73, number=0, name='a' * 49, buildid=30),
fakedb.Step(id=74, number=1, name='a' * 48 + '_1', buildid=30),
])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='a' * 49, state_string='new'
)
yield self.db.steps.startStep(stepid=stepid, started_at=TIME1, locks_acquired=False)
self.assertEqual((number, name), (2, 'a' * 48 + '_2'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(stepdict.number, number)
self.assertEqual(stepdict.name, name)
@defer.inlineCallbacks
def test_addStep_getStep_name_collisions_too_long_extra_digits(self):
yield self.insert_test_data(
self.backgroundData
+ [
fakedb.Step(id=73, number=0, name='a' * 50, buildid=30),
]
+ [
fakedb.Step(id=73 + i, number=i, name='a' * 48 + (f'_{i}'), buildid=30)
for i in range(1, 10)
]
+ [
fakedb.Step(id=73 + i, number=i, name='a' * 47 + (f'_{i}'), buildid=30)
for i in range(10, 100)
]
)
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='a' * 50, state_string='new'
)
yield self.db.steps.startStep(stepid=stepid, started_at=TIME1, locks_acquired=False)
self.assertEqual((number, name), (100, 'a' * 46 + '_100'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
self.assertIsInstance(stepdict, steps.StepModel)
self.assertEqual(stepdict.number, number)
self.assertEqual(stepdict.name, name)
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'steps',
'builds',
'builders',
'masters',
"projects",
'buildrequests',
'buildsets',
'workers',
]
)
self.db.steps = steps.StepsConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 17,034 | Python | .py | 408 | 31.860294 | 97 | 0.620513 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,404 | test_test_results.py | buildbot_buildbot/master/buildbot/test/unit/db/test_test_results.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import test_results
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
class Tests(interfaces.InterfaceTests):
common_data = [
fakedb.Worker(id=47, name='linux'),
fakedb.Buildset(id=20),
fakedb.Builder(id=88, name='b1'),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=88),
fakedb.Master(id=88),
fakedb.Build(id=30, buildrequestid=41, number=7, masterid=88, builderid=88, workerid=47),
fakedb.Step(id=131, number=132, name='step132', buildid=30),
fakedb.TestResultSet(
id=13,
builderid=88,
buildid=30,
stepid=131,
description='desc',
category='cat',
value_unit='ms',
complete=1,
),
]
def test_signature_get_test_code_paths(self):
@self.assertArgSpecMatches(self.db.test_results.getTestCodePaths)
def getTestCodePaths(self, builderid, path_prefix=None, result_spec=None):
pass
def test_signature_get_test_names(self):
@self.assertArgSpecMatches(self.db.test_results.getTestNames)
def getTestNames(self, builderid, name_prefix=None, result_spec=None):
pass
def test_signature_add_test_results(self):
@self.assertArgSpecMatches(self.db.test_results.addTestResults)
def addTestResults(self, builderid, test_result_setid, result_values):
pass
def test_signature_get_test_result(self):
@self.assertArgSpecMatches(self.db.test_results.getTestResult)
def getTestResult(self, test_resultid):
pass
def test_signature_get_test_results(self):
@self.assertArgSpecMatches(self.db.test_results.getTestResults)
def getTestResults(self, builderid, test_result_setid, result_spec=None):
pass
@defer.inlineCallbacks
def test_add_set_results(self):
yield self.insert_test_data(self.common_data)
result_values = [
{'test_name': 'name1', 'value': '1'},
{'test_name': 'name1', 'duration_ns': 1000, 'value': '2'},
{'test_name': 'name2', 'test_code_path': 'path2', 'value': '3'},
{'test_name': 'name3', 'test_code_path': 'path3', 'value': '4'},
{'test_name': 'name4', 'test_code_path': 'path4', 'line': 4, 'value': '5'},
{'test_code_path': 'path5', 'line': 5, 'value': '6'},
]
yield self.db.test_results.addTestResults(
builderid=88, test_result_setid=13, result_values=result_values
)
result_dicts = yield self.db.test_results.getTestResults(builderid=88, test_result_setid=13)
for d in result_dicts:
self.assertIsInstance(d, test_results.TestResultModel)
result_dicts = sorted(result_dicts, key=lambda x: x.id)
resultid = result_dicts[0].id
self.assertEqual(
result_dicts,
[
test_results.TestResultModel(
id=resultid,
builderid=88,
test_result_setid=13,
test_name='name1',
test_code_path=None,
line=None,
duration_ns=None,
value='1',
),
test_results.TestResultModel(
id=resultid + 1,
builderid=88,
test_result_setid=13,
test_name='name1',
test_code_path=None,
line=None,
duration_ns=1000,
value='2',
),
test_results.TestResultModel(
id=resultid + 2,
builderid=88,
test_result_setid=13,
test_name='name2',
test_code_path='path2',
line=None,
duration_ns=None,
value='3',
),
test_results.TestResultModel(
id=resultid + 3,
builderid=88,
test_result_setid=13,
test_name='name3',
test_code_path='path3',
line=None,
duration_ns=None,
value='4',
),
test_results.TestResultModel(
id=resultid + 4,
builderid=88,
test_result_setid=13,
test_name='name4',
test_code_path='path4',
line=4,
duration_ns=None,
value='5',
),
test_results.TestResultModel(
id=resultid + 5,
builderid=88,
test_result_setid=13,
test_name=None,
test_code_path='path5',
line=5,
duration_ns=None,
value='6',
),
],
)
result_dict = yield self.db.test_results.getTestResult(test_resultid=resultid)
self.assertEqual(
result_dict,
test_results.TestResultModel(
id=resultid,
builderid=88,
test_result_setid=13,
test_name='name1',
test_code_path=None,
line=None,
duration_ns=None,
value='1',
),
)
@defer.inlineCallbacks
def test_get_names(self):
yield self.insert_test_data([
*self.common_data,
fakedb.TestName(id=103, builderid=88, name='name103'),
fakedb.TestName(id=104, builderid=88, name='name104'),
fakedb.TestName(id=105, builderid=88, name='name105'),
fakedb.TestName(id=116, builderid=88, name='name116'),
fakedb.TestName(id=117, builderid=88, name='name117'),
])
name_dicts = yield self.db.test_results.getTestNames(builderid=88)
self.assertEqual(name_dicts, ['name103', 'name104', 'name105', 'name116', 'name117'])
name_dicts = yield self.db.test_results.getTestNames(
builderid=88, name_prefix='non_existing'
)
self.assertEqual(name_dicts, [])
name_dicts = yield self.db.test_results.getTestNames(builderid=88, name_prefix='name10')
self.assertEqual(name_dicts, ['name103', 'name104', 'name105'])
name_dicts = yield self.db.test_results.getTestNames(builderid=88, name_prefix='name11')
self.assertEqual(name_dicts, ['name116', 'name117'])
@defer.inlineCallbacks
def test_get_code_paths(self):
yield self.insert_test_data([
*self.common_data,
fakedb.TestCodePath(id=103, builderid=88, path='path103'),
fakedb.TestCodePath(id=104, builderid=88, path='path104'),
fakedb.TestCodePath(id=105, builderid=88, path='path105'),
fakedb.TestCodePath(id=116, builderid=88, path='path116'),
fakedb.TestCodePath(id=117, builderid=88, path='path117'),
])
path_dicts = yield self.db.test_results.getTestCodePaths(builderid=88)
self.assertEqual(path_dicts, ['path103', 'path104', 'path105', 'path116', 'path117'])
path_dicts = yield self.db.test_results.getTestCodePaths(
builderid=88, path_prefix='non_existing'
)
self.assertEqual(path_dicts, [])
path_dicts = yield self.db.test_results.getTestCodePaths(builderid=88, path_prefix='path10')
self.assertEqual(path_dicts, ['path103', 'path104', 'path105'])
path_dicts = yield self.db.test_results.getTestCodePaths(builderid=88, path_prefix='path11')
self.assertEqual(path_dicts, ['path116', 'path117'])
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, Tests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'steps',
'builds',
"projects",
'builders',
'masters',
'buildrequests',
'buildsets',
'workers',
'test_names',
'test_code_paths',
'test_results',
'test_result_sets',
]
)
self.db.test_results = test_results.TestResultsConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 9,482 | Python | .py | 220 | 30.495455 | 100 | 0.567638 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,405 | test_pool.py | buildbot_buildbot/master/buildbot/test/unit/db/test_pool.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import os
import time
import sqlalchemy as sa
from twisted.internet import defer
from twisted.internet import reactor
from twisted.trial import unittest
from buildbot.db import pool
from buildbot.test.util import db
from buildbot.util import sautils
class Basic(unittest.TestCase):
# basic tests, just using an in-memory SQL db and one thread
def setUp(self):
self.engine = sa.create_engine('sqlite://', future=True)
self.engine.should_retry = lambda _: False
self.engine.optimal_thread_pool_size = 1
self.pool = pool.DBThreadPool(self.engine, reactor=reactor)
@defer.inlineCallbacks
def tearDown(self):
yield self.pool.shutdown()
@defer.inlineCallbacks
def test_do(self):
def add(conn, addend1, addend2):
rp = conn.execute(sa.text(f"SELECT {addend1} + {addend2}"))
return rp.scalar()
res = yield self.pool.do(add, 10, 11)
self.assertEqual(res, 21)
@defer.inlineCallbacks
def expect_failure(self, d, expected_exception, expect_logged_error=False):
exception = None
try:
yield d
except Exception as e:
exception = e
errors = self.flushLoggedErrors(expected_exception)
if expect_logged_error:
self.assertEqual(len(errors), 1)
self.assertTrue(isinstance(exception, expected_exception))
def test_do_error(self):
def fail(conn):
rp = conn.execute(sa.text("EAT COOKIES"))
return rp.scalar()
return self.expect_failure(
self.pool.do(fail), sa.exc.OperationalError, expect_logged_error=True
)
def test_do_exception(self):
def raise_something(conn):
raise RuntimeError("oh noes")
return self.expect_failure(
self.pool.do(raise_something), RuntimeError, expect_logged_error=True
)
@defer.inlineCallbacks
def test_do_with_engine(self):
def add(engine, addend1, addend2):
with engine.connect() as conn:
rp = conn.execute(sa.text(f"SELECT {addend1} + {addend2}"))
return rp.scalar()
res = yield self.pool.do_with_engine(add, 10, 11)
self.assertEqual(res, 21)
def test_do_with_engine_exception(self):
def fail(engine):
with engine.connect() as conn:
rp = conn.execute(sa.text("EAT COOKIES"))
return rp.scalar()
return self.expect_failure(self.pool.do_with_engine(fail), sa.exc.OperationalError)
@defer.inlineCallbacks
def test_persistence_across_invocations(self):
# NOTE: this assumes that both methods are called with the same
# connection; if they run in parallel threads then it is not valid to
# assume that the database engine will have finalized the first
# transaction (and thus created the table) by the time the second
# transaction runs. This is why we set optimal_thread_pool_size in
# setUp.
def create_table(engine):
with engine.connect() as conn:
conn.execute(sa.text("CREATE TABLE tmp ( a integer )"))
conn.commit()
yield self.pool.do_with_engine(create_table)
def insert_into_table(engine):
with engine.connect() as conn:
conn.execute(sa.text("INSERT INTO tmp values ( 1 )"))
conn.commit()
yield self.pool.do_with_engine(insert_into_table)
class Stress(unittest.TestCase):
def setUp(self):
setup_engine = sa.create_engine('sqlite:///test.sqlite', future=True)
setup_engine.execute("pragma journal_mode = wal")
setup_engine.execute("CREATE TABLE test (a integer, b integer)")
self.engine = sa.create_engine('sqlite:///test.sqlite', future=True)
self.engine.optimal_thread_pool_size = 2
self.pool = pool.DBThreadPool(self.engine, reactor=reactor)
@defer.inlineCallbacks
def tearDown(self):
yield self.pool.shutdown()
os.unlink("test.sqlite")
@defer.inlineCallbacks
def test_inserts(self):
def write(conn):
trans = conn.begin()
conn.execute("INSERT INTO test VALUES (1, 1)")
time.sleep(31)
trans.commit()
d1 = self.pool.do(write)
def write2(conn):
trans = conn.begin()
conn.execute("INSERT INTO test VALUES (1, 1)")
trans.commit()
d2 = defer.Deferred()
d2.addCallback(lambda _: self.pool.do(write2))
reactor.callLater(0.1, d2.callback, None)
yield defer.DeferredList([d1, d2])
# don't run this test, since it takes 30s
del test_inserts
class BasicWithDebug(Basic):
# same thing, but with debug=True
def setUp(self):
pool.debug = True
return super().setUp()
def tearDown(self):
pool.debug = False
return super().tearDown()
class Native(unittest.TestCase, db.RealDatabaseMixin):
# similar tests, but using the BUILDBOT_TEST_DB_URL
@defer.inlineCallbacks
def setUp(self):
yield self.setUpRealDatabase(want_pool=False)
self.pool = pool.DBThreadPool(self.db_engine, reactor=reactor)
@defer.inlineCallbacks
def tearDown(self):
# try to delete the 'native_tests' table
meta = sa.MetaData()
native_tests = sautils.Table("native_tests", meta)
def thd(conn):
native_tests.drop(bind=self.db_engine, checkfirst=True)
yield self.pool.do(thd)
# tearDownRealDatabase() won't shutdown the pool as want_pool was false in
# setUpRealDatabase call
yield self.pool.shutdown()
yield self.tearDownRealDatabase()
@defer.inlineCallbacks
def test_ddl_and_queries(self):
meta = sa.MetaData()
native_tests = sautils.Table("native_tests", meta, sa.Column('name', sa.String(length=200)))
# perform a DDL operation and immediately try to access that table;
# this has caused problems in the past, so this is basically a
# regression test.
def ddl(conn):
t = conn.begin()
native_tests.create(bind=conn)
t.commit()
yield self.pool.do(ddl)
def access(conn):
conn.execute(native_tests.insert().values({'name': 'foo'}))
yield self.pool.do_with_transaction(access)
| 7,140 | Python | .py | 167 | 34.538922 | 100 | 0.656069 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,406 | test_builders.py | buildbot_buildbot/master/buildbot/test/unit/db/test_builders.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import builders
from buildbot.db import tags
from buildbot.db import workers
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
from buildbot.util.twisted import async_to_deferred
def builderKey(builder: builders.BuilderModel) -> int:
return builder.id
class Tests(interfaces.InterfaceTests):
# common sample data
builder_row = [
fakedb.Builder(id=7, name="some:builder"),
]
# tests
def test_signature_findBuilderId(self):
@self.assertArgSpecMatches(self.db.builders.findBuilderId)
def findBuilderId(self, name, autoCreate=True):
pass
def test_signature_addBuilderMaster(self):
@self.assertArgSpecMatches(self.db.builders.addBuilderMaster)
def addBuilderMaster(self, builderid=None, masterid=None):
pass
def test_signature_removeBuilderMaster(self):
@self.assertArgSpecMatches(self.db.builders.removeBuilderMaster)
def removeBuilderMaster(self, builderid=None, masterid=None):
pass
def test_signature_getBuilder(self):
@self.assertArgSpecMatches(self.db.builders.getBuilder)
def getBuilder(self, builderid):
pass
def test_signature_getBuilders(self):
@self.assertArgSpecMatches(self.db.builders.getBuilders)
def getBuilders(self, masterid=None, projectid=None, workerid=None):
pass
def test_signature_updateBuilderInfo(self):
@self.assertArgSpecMatches(self.db.builders.updateBuilderInfo)
def updateBuilderInfo(
self, builderid, description, description_format, description_html, projectid, tags
):
pass
@defer.inlineCallbacks
def test_updateBuilderInfo(self):
yield self.insert_test_data([
fakedb.Project(id=123, name="fake_project123"),
fakedb.Project(id=124, name="fake_project124"),
fakedb.Builder(id=7, name='some:builder7'),
fakedb.Builder(id=8, name='some:builder8'),
])
yield self.db.builders.updateBuilderInfo(
7, 'a string which describe the builder', None, None, 123, ['cat1', 'cat2']
)
yield self.db.builders.updateBuilderInfo(
8, 'a string which describe the builder', None, None, 124, []
)
builderdict7 = yield self.db.builders.getBuilder(7)
self.assertEqual(
builderdict7,
builders.BuilderModel(
id=7,
name='some:builder7',
tags=["cat1", "cat2"],
description="a string which describe the builder",
projectid=123,
),
)
builderdict8 = yield self.db.builders.getBuilder(8)
self.assertEqual(
builderdict8,
builders.BuilderModel(
id=8,
name='some:builder8',
description="a string which describe the builder",
projectid=124,
),
)
@defer.inlineCallbacks
def test_update_builder_info_tags_case(self):
yield self.insert_test_data([
fakedb.Project(id=107, name='fake_project'),
fakedb.Builder(id=7, name='some:builder7', projectid=107),
])
yield self.db.builders.updateBuilderInfo(7, 'builder_desc', None, None, 107, ['Cat', 'cat'])
builder_dict = yield self.db.builders.getBuilder(7)
self.assertEqual(
builder_dict,
builders.BuilderModel(
id=7,
name='some:builder7',
tags=['Cat', 'cat'],
description='builder_desc',
projectid=107,
),
)
@defer.inlineCallbacks
def test_findBuilderId_new(self):
id = yield self.db.builders.findBuilderId('some:builder')
builderdict = yield self.db.builders.getBuilder(id)
self.assertEqual(
builderdict,
builders.BuilderModel(
id=id,
name='some:builder',
),
)
@defer.inlineCallbacks
def test_findBuilderId_new_no_autoCreate(self):
id = yield self.db.builders.findBuilderId('some:builder', autoCreate=False)
self.assertIsNone(id)
@defer.inlineCallbacks
def test_findBuilderId_exists(self):
yield self.insert_test_data([
fakedb.Builder(id=7, name='some:builder'),
])
id = yield self.db.builders.findBuilderId('some:builder')
self.assertEqual(id, 7)
@defer.inlineCallbacks
def test_addBuilderMaster(self):
yield self.insert_test_data([
fakedb.Builder(id=7),
fakedb.Master(id=9, name='abc'),
fakedb.Master(id=10, name='def'),
fakedb.BuilderMaster(builderid=7, masterid=10),
])
yield self.db.builders.addBuilderMaster(builderid=7, masterid=9)
builderdict = yield self.db.builders.getBuilder(7)
self.assertEqual(
builderdict,
builders.BuilderModel(
id=7,
name='builder-7',
masterids=[9, 10],
),
)
@defer.inlineCallbacks
def test_addBuilderMaster_already_present(self):
yield self.insert_test_data([
fakedb.Builder(id=7),
fakedb.Master(id=9, name='abc'),
fakedb.Master(id=10, name='def'),
fakedb.BuilderMaster(builderid=7, masterid=9),
])
yield self.db.builders.addBuilderMaster(builderid=7, masterid=9)
builderdict = yield self.db.builders.getBuilder(7)
self.assertEqual(
builderdict,
builders.BuilderModel(
id=7,
name='builder-7',
masterids=[9],
),
)
@defer.inlineCallbacks
def test_removeBuilderMaster(self):
yield self.insert_test_data([
fakedb.Builder(id=7),
fakedb.Master(id=9),
fakedb.Master(id=10),
fakedb.BuilderMaster(builderid=7, masterid=9),
fakedb.BuilderMaster(builderid=7, masterid=10),
])
yield self.db.builders.removeBuilderMaster(builderid=7, masterid=9)
builderdict = yield self.db.builders.getBuilder(7)
self.assertEqual(
builderdict,
builders.BuilderModel(
id=7,
name='builder-7',
masterids=[10],
),
)
@defer.inlineCallbacks
def test_getBuilder_no_masters(self):
yield self.insert_test_data([
fakedb.Builder(id=7),
])
builderdict = yield self.db.builders.getBuilder(7)
self.assertEqual(
builderdict,
builders.BuilderModel(
id=7,
name='builder-7',
),
)
@defer.inlineCallbacks
def test_getBuilder_with_masters(self):
yield self.insert_test_data([
fakedb.Builder(id=7),
fakedb.Master(id=3, name='m1'),
fakedb.Master(id=4, name='m2'),
fakedb.BuilderMaster(builderid=7, masterid=3),
fakedb.BuilderMaster(builderid=7, masterid=4),
])
builderdict = yield self.db.builders.getBuilder(7)
self.assertEqual(
builderdict,
builders.BuilderModel(
id=7,
name='builder-7',
masterids=[3, 4],
),
)
@defer.inlineCallbacks
def test_getBuilder_missing(self):
builderdict = yield self.db.builders.getBuilder(7)
self.assertEqual(builderdict, None)
@defer.inlineCallbacks
def test_getBuilders(self):
yield self.insert_test_data([
fakedb.Builder(id=7, name='some:builder'),
fakedb.Builder(id=8, name='other:builder'),
fakedb.Builder(id=9, name='third:builder'),
fakedb.Master(id=3, name='m1'),
fakedb.Master(id=4, name='m2'),
fakedb.BuilderMaster(builderid=7, masterid=3),
fakedb.BuilderMaster(builderid=8, masterid=3),
fakedb.BuilderMaster(builderid=8, masterid=4),
])
builderlist = yield self.db.builders.getBuilders()
self.assertEqual(
sorted(builderlist, key=builderKey),
sorted(
[
builders.BuilderModel(
id=7,
name='some:builder',
masterids=[3],
),
builders.BuilderModel(
id=8,
name='other:builder',
masterids=[3, 4],
),
builders.BuilderModel(
id=9,
name='third:builder',
),
],
key=builderKey,
),
)
@defer.inlineCallbacks
def test_getBuilders_masterid(self):
yield self.insert_test_data([
fakedb.Builder(id=7, name='some:builder'),
fakedb.Builder(id=8, name='other:builder'),
fakedb.Builder(id=9, name='third:builder'),
fakedb.Master(id=3, name='m1'),
fakedb.Master(id=4, name='m2'),
fakedb.BuilderMaster(builderid=7, masterid=3),
fakedb.BuilderMaster(builderid=8, masterid=3),
fakedb.BuilderMaster(builderid=8, masterid=4),
])
builderlist = yield self.db.builders.getBuilders(masterid=3)
self.assertEqual(
sorted(builderlist, key=builderKey),
sorted(
[
builders.BuilderModel(
id=7,
name='some:builder',
masterids=[3],
),
builders.BuilderModel(
id=8,
name='other:builder',
masterids=[3, 4],
),
],
key=builderKey,
),
)
@defer.inlineCallbacks
def test_getBuilders_projectid(self):
yield self.insert_test_data([
fakedb.Project(id=201, name="p201"),
fakedb.Project(id=202, name="p202"),
fakedb.Builder(id=101, name="b101"),
fakedb.Builder(id=102, name="b102", projectid=201),
fakedb.Builder(id=103, name="b103", projectid=201),
fakedb.Builder(id=104, name="b104", projectid=202),
fakedb.Master(id=3, name='m1'),
fakedb.Master(id=4, name='m2'),
fakedb.BuilderMaster(builderid=101, masterid=3),
fakedb.BuilderMaster(builderid=102, masterid=3),
fakedb.BuilderMaster(builderid=103, masterid=4),
fakedb.BuilderMaster(builderid=104, masterid=4),
])
builderlist = yield self.db.builders.getBuilders(projectid=201)
self.assertEqual(
sorted(builderlist, key=builderKey),
sorted(
[
builders.BuilderModel(
id=102,
name="b102",
masterids=[3],
projectid=201,
),
builders.BuilderModel(
id=103,
name="b103",
masterids=[4],
projectid=201,
),
],
key=builderKey,
),
)
@async_to_deferred
async def test_getBuilders_workerid(self):
await self.insert_test_data([
fakedb.Builder(id=101, name="b101"),
fakedb.Builder(id=102, name="b102"),
fakedb.Builder(id=103, name="b103"),
fakedb.Builder(id=104, name="b104"),
fakedb.Master(id=3, name='m1'),
fakedb.BuilderMaster(id=1, builderid=101, masterid=3),
fakedb.BuilderMaster(id=2, builderid=102, masterid=3),
fakedb.BuilderMaster(id=3, builderid=103, masterid=3),
fakedb.BuilderMaster(id=4, builderid=104, masterid=3),
fakedb.Worker(id=1, name='zero'),
fakedb.ConnectedWorker(id=1, workerid=1, masterid=3),
fakedb.ConfiguredWorker(id=1, workerid=1, buildermasterid=2),
fakedb.ConfiguredWorker(id=2, workerid=1, buildermasterid=3),
])
builderlist = await self.db.builders.getBuilders(workerid=1)
self.assertEqual(
sorted(builderlist, key=builderKey),
sorted(
[
builders.BuilderModel(
id=102,
name="b102",
masterids=[3],
),
builders.BuilderModel(
id=103,
name="b103",
masterids=[3],
),
],
key=builderKey,
),
)
@defer.inlineCallbacks
def test_getBuilders_empty(self):
builderlist = yield self.db.builders.getBuilders()
self.assertEqual(sorted(builderlist), [])
class RealTests(Tests):
# tests that only "real" implementations will pass
pass
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'projects',
'builders',
'masters',
'builder_masters',
'builders_tags',
'tags',
'workers',
'connected_workers',
'configured_workers',
]
)
self.db.builders = builders.BuildersConnectorComponent(self.db)
self.db.tags = tags.TagsConnectorComponent(self.db)
self.db.workers = workers.WorkersConnectorComponent(self.db)
self.master = self.db.master
self.master.db = self.db
def tearDown(self):
return self.tearDownConnectorComponent()
| 15,102 | Python | .py | 392 | 26.553571 | 100 | 0.567592 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,407 | test_builds.py | buildbot_buildbot/master/buildbot/test/unit/db/test_builds.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.data import resultspec
from buildbot.db import builds
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
from buildbot.util import epoch2datetime
TIME1 = 1304262222
TIME2 = 1304262223
TIME3 = 1304262224
TIME4 = 1304262235
CREATED_AT = 927845299
class Tests(interfaces.InterfaceTests):
# common sample data
backgroundData = [
fakedb.Buildset(id=20),
fakedb.Builder(id=77, name="b1"),
fakedb.Builder(id=88, name="b2"),
fakedb.BuildRequest(id=40, buildsetid=20, builderid=77),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=77),
fakedb.BuildRequest(id=42, buildsetid=20, builderid=88),
fakedb.Master(id=88),
fakedb.Master(id=89, name="bar"),
fakedb.Worker(id=13, name='wrk'),
fakedb.Worker(id=12, name='sl2'),
]
threeBuilds = [
fakedb.Build(
id=50,
buildrequestid=42,
number=5,
masterid=88,
builderid=77,
workerid=13,
state_string="build 5",
started_at=TIME1,
),
fakedb.Build(
id=51,
buildrequestid=41,
number=6,
masterid=88,
builderid=88,
workerid=13,
state_string="build 6",
started_at=TIME2,
),
fakedb.Build(
id=52,
buildrequestid=42,
number=7,
masterid=88,
builderid=77,
workerid=12,
state_string="build 7",
started_at=TIME3,
complete_at=TIME4,
results=5,
),
]
threeBdicts = {
50: builds.BuildModel(
id=50,
buildrequestid=42,
builderid=77,
masterid=88,
number=5,
workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=None,
locks_duration_s=0,
state_string="build 5",
results=None,
),
51: builds.BuildModel(
id=51,
buildrequestid=41,
builderid=88,
masterid=88,
number=6,
workerid=13,
started_at=epoch2datetime(TIME2),
complete_at=None,
locks_duration_s=0,
state_string="build 6",
results=None,
),
52: builds.BuildModel(
id=52,
buildrequestid=42,
builderid=77,
masterid=88,
number=7,
workerid=12,
started_at=epoch2datetime(TIME3),
complete_at=epoch2datetime(TIME4),
locks_duration_s=0,
state_string="build 7",
results=5,
),
}
# signature tests
def test_signature_getBuild(self):
@self.assertArgSpecMatches(self.db.builds.getBuild)
def getBuild(self, buildid):
pass
def test_signature_getBuildByNumber(self):
@self.assertArgSpecMatches(self.db.builds.getBuildByNumber)
def getBuild(self, builderid, number):
pass
def test_signature_getBuilds(self):
@self.assertArgSpecMatches(self.db.builds.getBuilds)
def getBuilds(
self, builderid=None, buildrequestid=None, workerid=None, complete=None, resultSpec=None
):
pass
def test_signature_addBuild(self):
@self.assertArgSpecMatches(self.db.builds.addBuild)
def addBuild(self, builderid, buildrequestid, workerid, masterid, state_string):
pass
def test_signature_setBuildStateString(self):
@self.assertArgSpecMatches(self.db.builds.setBuildStateString)
def setBuildStateString(self, buildid, state_string):
pass
def test_signature_add_build_locks_duration(self):
@self.assertArgSpecMatches(self.db.builds.add_build_locks_duration)
def setBuildStateString(self, buildid, duration_s):
pass
def test_signature_finishBuild(self):
@self.assertArgSpecMatches(self.db.builds.finishBuild)
def finishBuild(self, buildid, results):
pass
def test_signature_getBuildProperties(self):
@self.assertArgSpecMatches(self.db.builds.getBuildProperties)
def getBuildProperties(self, bid, resultSpec=None):
pass
def test_signature_setBuildProperty(self):
@self.assertArgSpecMatches(self.db.builds.setBuildProperty)
def setBuildProperty(self, bid, name, value, source):
pass
# method tests
@defer.inlineCallbacks
def test_getBuild(self):
yield self.insert_test_data([*self.backgroundData, self.threeBuilds[0]])
bdict = yield self.db.builds.getBuild(50)
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
bdict,
builds.BuildModel(
id=50,
number=5,
buildrequestid=42,
masterid=88,
builderid=77,
workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=None,
locks_duration_s=0,
state_string='build 5',
results=None,
),
)
@defer.inlineCallbacks
def test_getBuild_missing(self):
bdict = yield self.db.builds.getBuild(50)
self.assertEqual(bdict, None)
@defer.inlineCallbacks
def test_getBuildByNumber(self):
yield self.insert_test_data([*self.backgroundData, self.threeBuilds[0]])
bdict = yield self.db.builds.getBuildByNumber(builderid=77, number=5)
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(bdict.id, 50)
@defer.inlineCallbacks
def test_getBuilds(self):
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds()
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
sorted(bdicts, key=lambda bd: bd.id),
[self.threeBdicts[50], self.threeBdicts[51], self.threeBdicts[52]],
)
@defer.inlineCallbacks
def test_getBuilds_builderid(self):
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(builderid=88)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[51]])
@defer.inlineCallbacks
def test_getBuilds_buildrequestid(self):
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(buildrequestid=42)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[50], self.threeBdicts[52]]
)
@defer.inlineCallbacks
def test_getBuilds_workerid(self):
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(workerid=13)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[50], self.threeBdicts[51]]
)
def test_signature_getBuildsForChange(self):
@self.assertArgSpecMatches(self.db.builds.getBuildsForChange)
def getBuildsForChange(self, changeid):
pass
@defer.inlineCallbacks
def do_test_getBuildsForChange(self, rows, changeid, expected):
yield self.insert_test_data(rows)
builds = yield self.db.builds.getBuildsForChange(changeid)
self.assertEqual(sorted(builds), sorted(expected))
def test_getBuildsForChange_OneCodebase(self):
rows = [
fakedb.Master(id=88, name="bar"),
fakedb.Worker(id=13, name='one'),
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, created_at=CREATED_AT, revision="aaa"),
fakedb.Change(changeid=14, codebase='A', sourcestampid=234),
fakedb.Buildset(id=30, reason='foo', submitted_at=1300305712, results=1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.BuildRequest(
id=19,
buildsetid=30,
builderid=77,
priority=13,
submitted_at=1300305712,
results=1,
complete=0,
complete_at=None,
),
fakedb.Build(
id=50,
buildrequestid=19,
number=5,
masterid=88,
builderid=77,
state_string="test",
workerid=13,
started_at=1304262222,
results=1,
),
]
expected = [
builds.BuildModel(
id=50,
number=5,
builderid=77,
buildrequestid=19,
workerid=13,
masterid=88,
started_at=epoch2datetime(1304262222),
complete_at=None,
locks_duration_s=0,
state_string='test',
results=1,
),
]
return self.do_test_getBuildsForChange(rows, 14, expected)
@defer.inlineCallbacks
def test_getBuilds_complete(self):
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(complete=True)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[52]])
@defer.inlineCallbacks
def test_addBuild_first(self):
self.reactor.advance(TIME1)
yield self.insert_test_data(self.backgroundData)
id, number = yield self.db.builds.addBuild(
builderid=77, buildrequestid=41, workerid=13, masterid=88, state_string='test test2'
)
bdict = yield self.db.builds.getBuild(id)
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
bdict,
builds.BuildModel(
buildrequestid=41,
builderid=77,
id=id,
masterid=88,
number=number,
workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=None,
locks_duration_s=0,
state_string="test test2",
results=None,
),
)
@defer.inlineCallbacks
def test_addBuild_existing(self):
self.reactor.advance(TIME1)
yield self.insert_test_data([
*self.backgroundData,
fakedb.Build(number=10, buildrequestid=41, builderid=77, masterid=88, workerid=13),
])
id, number = yield self.db.builds.addBuild(
builderid=77, buildrequestid=41, workerid=13, masterid=88, state_string='test test2'
)
bdict = yield self.db.builds.getBuild(id)
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(number, 11)
self.assertEqual(
bdict,
builds.BuildModel(
buildrequestid=41,
builderid=77,
id=id,
masterid=88,
number=number,
workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=None,
locks_duration_s=0,
state_string="test test2",
results=None,
),
)
@defer.inlineCallbacks
def test_setBuildStateString(self):
yield self.insert_test_data([*self.backgroundData, self.threeBuilds[0]])
yield self.db.builds.setBuildStateString(buildid=50, state_string='test test2')
bdict = yield self.db.builds.getBuild(50)
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
bdict,
builds.BuildModel(
id=50,
number=5,
buildrequestid=42,
masterid=88,
builderid=77,
workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=None,
locks_duration_s=0,
state_string='test test2',
results=None,
),
)
@defer.inlineCallbacks
def test_add_build_locks_duration(self):
yield self.insert_test_data([*self.backgroundData, self.threeBuilds[0]])
yield self.db.builds.add_build_locks_duration(buildid=50, duration_s=12)
bdict = yield self.db.builds.getBuild(50)
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
bdict,
builds.BuildModel(
id=50,
number=5,
buildrequestid=42,
masterid=88,
builderid=77,
workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=None,
locks_duration_s=12,
state_string="build 5",
results=None,
),
)
@defer.inlineCallbacks
def test_finishBuild(self):
self.reactor.advance(TIME4)
yield self.insert_test_data([*self.backgroundData, self.threeBuilds[0]])
yield self.db.builds.finishBuild(buildid=50, results=7)
bdict = yield self.db.builds.getBuild(50)
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
bdict,
builds.BuildModel(
id=50,
number=5,
buildrequestid=42,
masterid=88,
builderid=77,
workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=epoch2datetime(TIME4),
locks_duration_s=0,
state_string='build 5',
results=7,
),
)
@defer.inlineCallbacks
def testgetBuildPropertiesEmpty(self):
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
for buildid in (50, 51, 52):
props = yield self.db.builds.getBuildProperties(buildid)
self.assertEqual(0, len(props))
@defer.inlineCallbacks
def test_testgetBuildProperties_resultSpecFilter(self):
rs = resultspec.ResultSpec(filters=[resultspec.Filter('name', 'eq', ["prop", "prop2"])])
rs.fieldMapping = {'name': 'build_properties.name'}
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
yield self.db.builds.setBuildProperty(50, 'prop', 42, 'test')
yield self.db.builds.setBuildProperty(50, 'prop2', 43, 'test')
yield self.db.builds.setBuildProperty(50, 'prop3', 44, 'test')
props = yield self.db.builds.getBuildProperties(50, resultSpec=rs)
self.assertEqual(props, {'prop': (42, 'test'), 'prop2': (43, 'test')})
rs = resultspec.ResultSpec(filters=[resultspec.Filter('name', 'eq', ["prop"])])
rs.fieldMapping = {'name': 'build_properties.name'}
props = yield self.db.builds.getBuildProperties(50, resultSpec=rs)
self.assertEqual(
props,
{
'prop': (42, 'test'),
},
)
@defer.inlineCallbacks
def testsetandgetProperties(self):
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
yield self.db.builds.setBuildProperty(50, 'prop', 42, 'test')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (42, 'test')})
@defer.inlineCallbacks
def testsetgetsetProperties(self):
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {})
yield self.db.builds.setBuildProperty(50, 'prop', 42, 'test')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (42, 'test')})
# set a new value
yield self.db.builds.setBuildProperty(50, 'prop', 45, 'test')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (45, 'test')})
# set a new source
yield self.db.builds.setBuildProperty(50, 'prop', 45, 'test_source')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (45, 'test_source')})
# set the same
yield self.db.builds.setBuildProperty(50, 'prop', 45, 'test_source')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (45, 'test_source')})
class RealTests(Tests):
@defer.inlineCallbacks
def test_addBuild_existing_race(self):
self.reactor.advance(TIME1)
yield self.insert_test_data(self.backgroundData)
# add new builds at *just* the wrong time, repeatedly
numbers = list(range(1, 8))
def raceHook(conn):
if not numbers:
return
conn.execute(
self.db.model.builds.insert(),
{
"number": numbers.pop(0),
"buildrequestid": 41,
"masterid": 88,
"workerid": 13,
"builderid": 77,
"started_at": TIME1,
"locks_duration_s": 0,
"state_string": "hi",
},
)
conn.commit()
id, number = yield self.db.builds.addBuild(
builderid=77,
buildrequestid=41,
workerid=13,
masterid=88,
state_string='test test2',
_race_hook=raceHook,
)
bdict = yield self.db.builds.getBuild(id)
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(number, 8)
self.assertEqual(
bdict,
builds.BuildModel(
buildrequestid=41,
builderid=77,
id=id,
masterid=88,
number=number,
workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=None,
locks_duration_s=0,
state_string="test test2",
results=None,
),
)
@defer.inlineCallbacks
def test_getBuilds_resultSpecFilter(self):
rs = resultspec.ResultSpec(filters=[resultspec.Filter('complete_at', 'ne', [None])])
rs.fieldMapping = {'complete_at': 'builds.complete_at'}
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(resultSpec=rs)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[52]])
@defer.inlineCallbacks
def test_getBuilds_resultSpecOrder(self):
rs = resultspec.ResultSpec(order=['-started_at'])
rs.fieldMapping = {'started_at': 'builds.started_at'}
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(resultSpec=rs)
# applying the spec in the db layer should have emptied the order in
# resultSpec
self.assertEqual(rs.order, None)
# assert applying the same order at the data layer will give the same
# results
rs = resultspec.ResultSpec(order=['-started_at'])
ordered_bdicts = rs.apply(bdicts)
self.assertEqual(ordered_bdicts, bdicts)
# assert applying an opposite order at the data layer will give different
# results
rs = resultspec.ResultSpec(order=['started_at'])
ordered_bdicts = rs.apply(bdicts)
self.assertNotEqual(ordered_bdicts, bdicts)
@defer.inlineCallbacks
def test_getBuilds_limit(self):
rs = resultspec.ResultSpec(order=['-started_at'], limit=1, offset=2)
rs.fieldMapping = {'started_at': 'builds.started_at'}
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(resultSpec=rs)
# applying the spec in the db layer should have emptied the limit and
# offset in resultSpec
self.assertEqual(rs.limit, None)
self.assertEqual(rs.offset, None)
# assert applying the same filter at the data layer will give the same
# results
rs = resultspec.ResultSpec(order=['-started_at'], limit=1, offset=2)
bdicts2 = yield self.db.builds.getBuilds()
ordered_bdicts = rs.apply(bdicts2)
self.assertEqual(ordered_bdicts, bdicts)
@defer.inlineCallbacks
def test_getBuilds_resultSpecFilterEqTwoValues(self):
rs = resultspec.ResultSpec(filters=[resultspec.Filter('number', 'eq', [6, 7])])
rs.fieldMapping = {'number': 'builds.number'}
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(resultSpec=rs)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[51], self.threeBdicts[52]]
)
@defer.inlineCallbacks
def test_getBuilds_resultSpecFilterNeTwoValues(self):
rs = resultspec.ResultSpec(filters=[resultspec.Filter('number', 'ne', [6, 7])])
rs.fieldMapping = {'number': 'builds.number'}
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(resultSpec=rs)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[50]])
@defer.inlineCallbacks
def test_getBuilds_resultSpecFilterContainsOneValue(self):
rs = resultspec.ResultSpec(filters=[resultspec.Filter('state_string', 'contains', ['7'])])
rs.fieldMapping = {'state_string': 'builds.state_string'}
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(resultSpec=rs)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[52]])
@defer.inlineCallbacks
def test_getBuilds_resultSpecFilterContainsTwoValues(self):
rs = resultspec.ResultSpec(
filters=[resultspec.Filter('state_string', 'contains', ['build 5', 'build 6'])]
)
rs.fieldMapping = {'state_string': 'builds.state_string'}
yield self.insert_test_data(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(resultSpec=rs)
for bdict in bdicts:
self.assertIsInstance(bdict, builds.BuildModel)
self.assertEqual(
sorted(bdicts, key=lambda bd: bd.id), [self.threeBdicts[50], self.threeBdicts[51]]
)
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'builds',
'builders',
'masters',
'buildrequests',
'buildsets',
'workers',
'build_properties',
'changes',
'sourcestamps',
'buildset_sourcestamps',
'patches',
"projects",
]
)
self.db.builds = builds.BuildsConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 25,055 | Python | .py | 616 | 29.785714 | 100 | 0.605842 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,408 | test_buildsets.py | buildbot_buildbot/master/buildbot/test/unit/db/test_buildsets.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import datetime
import json
from unittest import mock
from twisted.internet import defer
from buildbot.db import buildsets
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import db
from buildbot.test.util import interfaces
from buildbot.util import UTC
from buildbot.util import datetime2epoch
from buildbot.util import epoch2datetime
class Tests(interfaces.InterfaceTests):
def setUpTests(self):
self.now = 9272359
self.reactor.advance(self.now)
# set up a sourcestamp with id 234 for use below
return self.insert_test_data([
fakedb.SourceStamp(id=234),
fakedb.Builder(id=1, name='bldr1'),
fakedb.Builder(id=2, name='bldr2'),
])
def test_signature_addBuildset(self):
@self.assertArgSpecMatches(self.db.buildsets.addBuildset)
def addBuildset(
self,
sourcestamps,
reason,
properties,
builderids,
waited_for,
external_idstring=None,
submitted_at=None,
rebuilt_buildid=None,
parent_buildid=None,
parent_relationship=None,
priority=0,
):
pass
def test_signature_completeBuildset(self):
@self.assertArgSpecMatches(self.db.buildsets.completeBuildset)
def completeBuildset(self, bsid, results, complete_at=None):
pass
def test_signature_getBuildset(self):
@self.assertArgSpecMatches(self.db.buildsets.getBuildset)
def getBuildset(self, bsid):
pass
def test_signature_getBuildsets(self):
@self.assertArgSpecMatches(self.db.buildsets.getBuildsets)
def getBuildsets(self, complete=None, resultSpec=None):
pass
def test_signature_getRecentBuildsets(self):
@self.assertArgSpecMatches(self.db.buildsets.getRecentBuildsets)
def getBuildsets(self, count=None, branch=None, repository=None, complete=None):
pass
def test_signature_getBuildsetProperties(self):
@self.assertArgSpecMatches(self.db.buildsets.getBuildsetProperties)
def getBuildsetProperties(self, key, no_cache=False):
pass
@defer.inlineCallbacks
def test_addBuildset_getBuildset(self):
bsid, _ = yield self.db.buildsets.addBuildset(
sourcestamps=[234],
reason='because',
properties={},
builderids=[1],
external_idstring='extid',
waited_for=False,
)
# TODO: verify buildrequests too
bsdict = yield self.db.buildsets.getBuildset(bsid)
self.assertIsInstance(bsdict, buildsets.BuildSetModel)
self.assertEqual(
bsdict,
buildsets.BuildSetModel(
bsid=bsid,
external_idstring='extid',
reason='because',
submitted_at=datetime.datetime(1970, 4, 18, 7, 39, 19, tzinfo=UTC),
results=-1,
sourcestamps=[234],
),
)
@defer.inlineCallbacks
def test_addBuildset_getBuildset_explicit_submitted_at(self):
bsid_brids = yield self.db.buildsets.addBuildset(
sourcestamps=[234],
reason='because',
properties={},
builderids=[1],
external_idstring='extid',
submitted_at=epoch2datetime(8888888),
waited_for=False,
)
bsdict = yield self.db.buildsets.getBuildset(bsid_brids[0])
self.assertIsInstance(bsdict, buildsets.BuildSetModel)
self.assertEqual(
bsdict,
buildsets.BuildSetModel(
bsid=bsid_brids[0],
external_idstring='extid',
reason='because',
sourcestamps=[234],
submitted_at=datetime.datetime(1970, 4, 13, 21, 8, 8, tzinfo=UTC),
results=-1,
),
)
@defer.inlineCallbacks
def do_test_getBuildsetProperties(self, buildsetid, rows, expected):
yield self.insert_test_data(rows)
props = yield self.db.buildsets.getBuildsetProperties(buildsetid)
self.assertEqual(props, expected)
def test_getBuildsetProperties_multiple(self):
return self.do_test_getBuildsetProperties(
91,
[
fakedb.Buildset(id=91, complete=0, results=-1, submitted_at=0),
fakedb.BuildsetProperty(
buildsetid=91, property_name='prop1', property_value='["one", "fake1"]'
),
fakedb.BuildsetProperty(
buildsetid=91, property_name='prop2', property_value='["two", "fake2"]'
),
],
{"prop1": ('one', 'fake1'), "prop2": ('two', 'fake2')},
)
def test_getBuildsetProperties_empty(self):
return self.do_test_getBuildsetProperties(
91,
[
fakedb.Buildset(id=91, complete=0, results=-1, submitted_at=0),
],
{},
)
def test_getBuildsetProperties_nosuch(self):
"returns an empty dict even if no such buildset exists"
return self.do_test_getBuildsetProperties(91, [], {})
@defer.inlineCallbacks
def test_getBuildset_incomplete_zero(self):
yield self.insert_test_data([
fakedb.Buildset(
id=91,
complete=0,
complete_at=0,
results=-1,
submitted_at=266761875,
external_idstring='extid',
reason='rsn',
),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=234),
])
bsdict = yield self.db.buildsets.getBuildset(91)
self.assertIsInstance(bsdict, buildsets.BuildSetModel)
self.assertEqual(
bsdict,
buildsets.BuildSetModel(
bsid=91,
external_idstring='extid',
reason='rsn',
sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15, tzinfo=UTC),
complete=False,
complete_at=epoch2datetime(0),
results=-1,
),
)
@defer.inlineCallbacks
def test_getBuildset_complete(self):
yield self.insert_test_data([
fakedb.Buildset(
id=91,
complete=1,
complete_at=298297875,
results=-1,
submitted_at=266761875,
external_idstring='extid',
reason='rsn',
),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=234),
])
bsdict = yield self.db.buildsets.getBuildset(91)
self.assertIsInstance(bsdict, buildsets.BuildSetModel)
self.assertEqual(
bsdict,
buildsets.BuildSetModel(
bsid=91,
external_idstring='extid',
reason='rsn',
sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15, tzinfo=UTC),
complete=True,
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 15, tzinfo=UTC),
results=-1,
),
)
@defer.inlineCallbacks
def test_getBuildset_nosuch(self):
bsdict = yield self.db.buildsets.getBuildset(91)
self.assertEqual(bsdict, None)
def insert_test_getBuildsets_data(self):
return self.insert_test_data([
fakedb.Buildset(
id=91,
complete=0,
complete_at=298297875,
results=-1,
submitted_at=266761875,
external_idstring='extid',
reason='rsn1',
),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=234),
fakedb.Buildset(
id=92,
complete=1,
complete_at=298297876,
results=7,
submitted_at=266761876,
external_idstring='extid',
reason='rsn2',
),
fakedb.BuildsetSourceStamp(buildsetid=92, sourcestampid=234),
])
@defer.inlineCallbacks
def test_getBuildsets_empty(self):
bsdictlist = yield self.db.buildsets.getBuildsets()
self.assertEqual(bsdictlist, [])
@defer.inlineCallbacks
def test_getBuildsets_all(self):
yield self.insert_test_getBuildsets_data()
bsdictlist = yield self.db.buildsets.getBuildsets()
def bsdictKey(bsdict):
return bsdict.reason
for bsdict in bsdictlist:
self.assertIsInstance(bsdict, buildsets.BuildSetModel)
self.assertEqual(
sorted(bsdictlist, key=bsdictKey),
sorted(
[
buildsets.BuildSetModel(
bsid=91,
external_idstring='extid',
reason='rsn1',
sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 15, tzinfo=UTC),
complete=False,
results=-1,
),
buildsets.BuildSetModel(
bsid=92,
external_idstring='extid',
reason='rsn2',
sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 16, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 16, tzinfo=UTC),
complete=True,
results=7,
),
],
key=bsdictKey,
),
)
@defer.inlineCallbacks
def test_getBuildsets_complete(self):
yield self.insert_test_getBuildsets_data()
bsdictlist = yield self.db.buildsets.getBuildsets(complete=True)
for bsdict in bsdictlist:
self.assertIsInstance(bsdict, buildsets.BuildSetModel)
self.assertEqual(
bsdictlist,
[
buildsets.BuildSetModel(
bsid=92,
external_idstring='extid',
reason='rsn2',
sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 16, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 16, tzinfo=UTC),
complete=True,
results=7,
),
],
)
@defer.inlineCallbacks
def test_getBuildsets_incomplete(self):
yield self.insert_test_getBuildsets_data()
bsdictlist = yield self.db.buildsets.getBuildsets(complete=False)
for bsdict in bsdictlist:
self.assertIsInstance(bsdict, buildsets.BuildSetModel)
self.assertEqual(
bsdictlist,
[
buildsets.BuildSetModel(
bsid=91,
external_idstring='extid',
reason='rsn1',
sourcestamps=[234],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 15, tzinfo=UTC),
complete=False,
results=-1,
),
],
)
def test_completeBuildset_already_completed(self):
d = self.insert_test_getBuildsets_data()
d.addCallback(lambda _: self.db.buildsets.completeBuildset(bsid=92, results=6))
return self.assertFailure(d, buildsets.AlreadyCompleteError)
def test_completeBuildset_missing(self):
d = self.insert_test_getBuildsets_data()
d.addCallback(lambda _: self.db.buildsets.completeBuildset(bsid=93, results=6))
return self.assertFailure(d, buildsets.AlreadyCompleteError)
@defer.inlineCallbacks
def test_completeBuildset(self):
yield self.insert_test_getBuildsets_data()
yield self.db.buildsets.completeBuildset(bsid=91, results=6)
bsdicts = yield self.db.buildsets.getBuildsets()
bsdicts = [
(
bsdict.bsid,
bsdict.complete,
datetime2epoch(bsdict.complete_at),
bsdict.results,
)
for bsdict in bsdicts
]
self.assertEqual(sorted(bsdicts), sorted([(91, 1, self.now, 6), (92, 1, 298297876, 7)]))
@defer.inlineCallbacks
def test_completeBuildset_explicit_complete_at(self):
yield self.insert_test_getBuildsets_data()
yield self.db.buildsets.completeBuildset(
bsid=91, results=6, complete_at=epoch2datetime(72759)
)
bsdicts = yield self.db.buildsets.getBuildsets()
bsdicts = [
(
bsdict.bsid,
bsdict.complete,
datetime2epoch(bsdict.complete_at),
bsdict.results,
)
for bsdict in bsdicts
]
self.assertEqual(sorted(bsdicts), sorted([(91, 1, 72759, 6), (92, 1, 298297876, 7)]))
def insert_test_getRecentBuildsets_data(self):
return self.insert_test_data([
fakedb.SourceStamp(id=91, branch='branch_a', repository='repo_a'),
fakedb.Buildset(
id=91,
complete=0,
complete_at=298297875,
results=-1,
submitted_at=266761875,
external_idstring='extid',
reason='rsn1',
),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=91),
fakedb.Buildset(
id=92,
complete=1,
complete_at=298297876,
results=7,
submitted_at=266761876,
external_idstring='extid',
reason='rsn2',
),
fakedb.BuildsetSourceStamp(buildsetid=92, sourcestampid=91),
# buildset unrelated to the change
fakedb.Buildset(
id=93,
complete=1,
complete_at=298297877,
results=7,
submitted_at=266761877,
external_idstring='extid',
reason='rsn2',
),
])
@defer.inlineCallbacks
def test_getRecentBuildsets_all(self):
yield self.insert_test_getRecentBuildsets_data()
bsdictlist = yield self.db.buildsets.getRecentBuildsets(
2, branch='branch_a', repository='repo_a'
)
self.assertEqual(
bsdictlist,
[
buildsets.BuildSetModel(
bsid=91,
external_idstring='extid',
reason='rsn1',
sourcestamps=[91],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 15, tzinfo=UTC),
complete=False,
results=-1,
),
buildsets.BuildSetModel(
bsid=92,
external_idstring='extid',
reason='rsn2',
sourcestamps=[91],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 16, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 16, tzinfo=UTC),
complete=True,
results=7,
),
],
)
@defer.inlineCallbacks
def test_getRecentBuildsets_one(self):
yield self.insert_test_getRecentBuildsets_data()
bsdictlist = yield self.db.buildsets.getRecentBuildsets(
1, branch='branch_a', repository='repo_a'
)
self.assertEqual(
bsdictlist,
[
buildsets.BuildSetModel(
bsid=92,
external_idstring='extid',
reason='rsn2',
sourcestamps=[91],
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 16, tzinfo=UTC),
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 16, tzinfo=UTC),
complete=True,
results=7,
),
],
)
@defer.inlineCallbacks
def test_getRecentBuildsets_zero(self):
yield self.insert_test_getRecentBuildsets_data()
bsdictlist = yield self.db.buildsets.getRecentBuildsets(
0, branch='branch_a', repository='repo_a'
)
self.assertEqual(bsdictlist, [])
@defer.inlineCallbacks
def test_getRecentBuildsets_noBranchMatch(self):
yield self.insert_test_getRecentBuildsets_data()
bsdictlist = yield self.db.buildsets.getRecentBuildsets(
2, branch='bad_branch', repository='repo_a'
)
self.assertEqual(bsdictlist, [])
@defer.inlineCallbacks
def test_getRecentBuildsets_noRepoMatch(self):
yield self.insert_test_getRecentBuildsets_data()
bsdictlist = yield self.db.buildsets.getRecentBuildsets(
2, branch='branch_a', repository='bad_repo'
)
self.assertEqual(bsdictlist, [])
class RealTests(Tests):
@defer.inlineCallbacks
def test_addBuildset_simple(self):
(bsid, brids) = yield self.db.buildsets.addBuildset(
sourcestamps=[234],
reason='because',
properties={},
builderids=[2],
external_idstring='extid',
waited_for=True,
)
def thd(conn):
# we should only have one brid
self.assertEqual(len(brids), 1)
# should see one buildset row
r = conn.execute(self.db.model.buildsets.select())
rows = [
(
row.id,
row.external_idstring,
row.reason,
row.complete,
row.complete_at,
row.submitted_at,
row.results,
)
for row in r.fetchall()
]
self.assertEqual(rows, [(bsid, 'extid', 'because', 0, None, self.now, -1)])
# one buildrequests row
r = conn.execute(self.db.model.buildrequests.select())
self.assertEqual(
r.keys(),
[
'id',
'buildsetid',
'builderid',
'priority',
'complete',
'results',
'submitted_at',
'complete_at',
'waited_for',
],
)
self.assertEqual(r.fetchall(), [(bsid, brids[2], 2, 0, 0, -1, self.now, None, 1)])
# one buildset_sourcestamps row
r = conn.execute(self.db.model.buildset_sourcestamps.select())
self.assertEqual(list(r.keys()), ['id', 'buildsetid', 'sourcestampid'])
self.assertEqual(r.fetchall(), [(1, bsid, 234)])
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_addBuildset_bigger(self):
props = {"prop": (['list'], 'test')}
yield defer.succeed(None)
xxx_todo_changeme1 = yield self.db.buildsets.addBuildset(
sourcestamps=[234],
reason='because',
waited_for=False,
properties=props,
builderids=[1, 2],
)
(bsid, brids) = xxx_todo_changeme1
def thd(conn):
self.assertEqual(len(brids), 2)
# should see one buildset row
r = conn.execute(self.db.model.buildsets.select())
rows = [
(
row.id,
row.external_idstring,
row.reason,
row.complete,
row.complete_at,
row.results,
)
for row in r.fetchall()
]
self.assertEqual(rows, [(bsid, None, 'because', 0, None, -1)])
# one property row
r = conn.execute(self.db.model.buildset_properties.select())
rows = [(row.buildsetid, row.property_name, row.property_value) for row in r.fetchall()]
self.assertEqual(rows, [(bsid, 'prop', json.dumps([['list'], 'test']))])
# one buildset_sourcestamps row
r = conn.execute(self.db.model.buildset_sourcestamps.select())
rows = [(row.buildsetid, row.sourcestampid) for row in r.fetchall()]
self.assertEqual(rows, [(bsid, 234)])
# and two buildrequests rows (and don't re-check the default
# columns)
r = conn.execute(self.db.model.buildrequests.select())
rows = [(row.buildsetid, row.id, row.builderid) for row in r.fetchall()]
# we don't know which of the brids is assigned to which
# buildername, but either one will do
self.assertEqual(sorted(rows), [(bsid, brids[1], 1), (bsid, brids[2], 2)])
yield self.db.pool.do(thd)
class TestRealDB(db.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'patches',
'buildsets',
'buildset_properties',
'objects',
'buildrequests',
'sourcestamps',
'buildset_sourcestamps',
'builders',
'builds',
'masters',
'workers',
"projects",
]
)
self.db.buildsets = buildsets.BuildsetsConnectorComponent(self.db)
yield self.setUpTests()
def tearDown(self):
return self.tearDownConnectorComponent()
@defer.inlineCallbacks
def test_addBuildset_properties_cache(self):
"""
Test that `addChange` properly seeds the `getChange` cache.
"""
# Patchup the buildset properties cache so we can verify that
# it got called form `addBuildset`.
mockedCachePut = mock.Mock()
self.patch(self.db.buildsets.getBuildsetProperties.cache, "put", mockedCachePut)
# Setup a dummy set of properties to insert with the buildset.
props = {"prop": (['list'], 'test')}
# Now, call `addBuildset`, and verify that the above properties
# were seed in the `getBuildsetProperties` cache.
bsid, _ = yield self.db.buildsets.addBuildset(
sourcestamps=[234],
reason='because',
properties=props,
builderids=[1, 2],
waited_for=False,
)
mockedCachePut.assert_called_once_with(bsid, props)
| 23,985 | Python | .py | 604 | 26.837748 | 100 | 0.554073 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,409 | test_dbconfig.py | buildbot_buildbot/master/buildbot/test/unit/db/test_dbconfig.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.internet import threads
from twisted.trial import unittest
from buildbot.db import dbconfig
from buildbot.test.util import db
class TestDbConfig(db.RealDatabaseMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
# as we will open the db twice, we can't use in memory sqlite
yield self.setUpRealDatabase(table_names=['objects', 'object_state'], sqlite_memory=False)
yield threads.deferToThread(self.createDbConfig)
def createDbConfig(self):
self.dbConfig = dbconfig.DbConfig({"db_url": self.db_url}, self.basedir)
def tearDown(self):
return self.tearDownRealDatabase()
def test_basic(self):
def thd():
workersInDB = ['foo', 'bar']
self.dbConfig.set("workers", workersInDB)
workers = self.dbConfig.get("workers")
self.assertEqual(workers, workersInDB)
return threads.deferToThread(thd)
def test_default(self):
def thd():
workers = self.dbConfig.get("workers", "default")
self.assertEqual(workers, "default")
return threads.deferToThread(thd)
def test_error(self):
def thd():
with self.assertRaises(KeyError):
self.dbConfig.get("workers")
return threads.deferToThread(thd)
# supports the 3 different ways to declare db_url in the master.cfg
def test_init1(self):
obj = dbconfig.DbConfig({"db_url": self.db_url}, self.basedir)
self.assertEqual(obj.db_url, self.db_url)
def test_init2(self):
obj = dbconfig.DbConfig({"db": {"db_url": self.db_url}}, self.basedir)
self.assertEqual(obj.db_url, self.db_url)
def test_init3(self):
obj = dbconfig.DbConfig({}, self.basedir)
self.assertEqual(obj.db_url, "sqlite:///state.sqlite")
class TestDbConfigNotInitialized(db.RealDatabaseMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
# as we will open the db twice, we can't use in memory sqlite
yield self.setUpRealDatabase(table_names=[], sqlite_memory=False)
@defer.inlineCallbacks
def tearDown(self):
yield self.tearDownRealDatabase()
def createDbConfig(self, db_url=None):
return dbconfig.DbConfig({"db_url": db_url or self.db_url}, self.basedir)
def test_default(self):
def thd():
db = self.createDbConfig()
self.assertEqual("foo", db.get("workers", "foo"))
return threads.deferToThread(thd)
def test_error(self):
def thd():
db = self.createDbConfig()
with self.assertRaises(KeyError):
db.get("workers")
return threads.deferToThread(thd)
def test_bad_url(self):
def thd():
db = self.createDbConfig("garbage://")
with self.assertRaises(KeyError):
db.get("workers")
return threads.deferToThread(thd)
def test_bad_url2(self):
def thd():
db = self.createDbConfig("trash")
with self.assertRaises(KeyError):
db.get("workers")
return threads.deferToThread(thd)
def test_bad_url3(self):
def thd():
db = self.createDbConfig("sqlite://bad")
with self.assertRaises(KeyError):
db.get("workers")
return threads.deferToThread(thd)
| 4,136 | Python | .py | 95 | 35.747368 | 98 | 0.668495 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,410 | test_masters.py | buildbot_buildbot/master/buildbot/test/unit/db/test_masters.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import masters
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
from buildbot.util import epoch2datetime
SOMETIME = 1348971992
SOMETIME_DT = epoch2datetime(SOMETIME)
OTHERTIME = 1008971992
OTHERTIME_DT = epoch2datetime(OTHERTIME)
class Tests(interfaces.InterfaceTests):
# common sample data
master_row = [
fakedb.Master(id=7, active=1, last_active=SOMETIME),
]
# tests
def test_signature_findMasterId(self):
@self.assertArgSpecMatches(self.db.masters.findMasterId)
def findMasterId(self, name):
pass
def test_signature_setMasterState(self):
@self.assertArgSpecMatches(self.db.masters.setMasterState)
def setMasterState(self, masterid, active):
pass
def test_signature_getMaster(self):
@self.assertArgSpecMatches(self.db.masters.getMaster)
def getMaster(self, masterid):
pass
def test_signature_getMasters(self):
@self.assertArgSpecMatches(self.db.masters.getMasters)
def getMasters(self):
pass
@defer.inlineCallbacks
def test_findMasterId_new(self):
id = yield self.db.masters.findMasterId('master-7')
masterdict = yield self.db.masters.getMaster(id)
self.assertEqual(
masterdict,
masters.MasterModel(id=id, name='master-7', active=False, last_active=SOMETIME_DT),
)
@defer.inlineCallbacks
def test_findMasterId_new_name_differs_only_by_case(self):
yield self.insert_test_data([
fakedb.Master(id=7, name='some:master'),
])
id = yield self.db.masters.findMasterId('some:Master')
masterdict = yield self.db.masters.getMaster(id)
self.assertEqual(
masterdict,
masters.MasterModel(id=id, name='some:Master', active=False, last_active=SOMETIME_DT),
)
@defer.inlineCallbacks
def test_findMasterId_exists(self):
yield self.insert_test_data([
fakedb.Master(id=7, name='some:master'),
])
id = yield self.db.masters.findMasterId('some:master')
self.assertEqual(id, 7)
@defer.inlineCallbacks
def test_setMasterState_when_missing(self):
activated = yield self.db.masters.setMasterState(masterid=7, active=True)
self.assertFalse(activated)
@defer.inlineCallbacks
def test_setMasterState_true_when_active(self):
yield self.insert_test_data([
fakedb.Master(id=7, active=1, last_active=OTHERTIME),
])
activated = yield self.db.masters.setMasterState(masterid=7, active=True)
self.assertFalse(activated) # it was already active
masterdict = yield self.db.masters.getMaster(7)
self.assertEqual(
masterdict,
masters.MasterModel(id=7, name='master-7', active=True, last_active=SOMETIME_DT),
) # timestamp updated
@defer.inlineCallbacks
def test_setMasterState_true_when_inactive(self):
yield self.insert_test_data([
fakedb.Master(id=7, active=0, last_active=OTHERTIME),
])
activated = yield self.db.masters.setMasterState(masterid=7, active=True)
self.assertTrue(activated)
masterdict = yield self.db.masters.getMaster(7)
self.assertEqual(
masterdict,
masters.MasterModel(id=7, name='master-7', active=True, last_active=SOMETIME_DT),
)
@defer.inlineCallbacks
def test_setMasterState_false_when_active(self):
yield self.insert_test_data([
fakedb.Master(id=7, active=1, last_active=OTHERTIME),
])
deactivated = yield self.db.masters.setMasterState(masterid=7, active=False)
self.assertTrue(deactivated)
masterdict = yield self.db.masters.getMaster(7)
self.assertEqual(
masterdict,
masters.MasterModel(id=7, name='master-7', active=False, last_active=OTHERTIME_DT),
)
@defer.inlineCallbacks
def test_setMasterState_false_when_inactive(self):
yield self.insert_test_data([
fakedb.Master(id=7, active=0, last_active=OTHERTIME),
])
deactivated = yield self.db.masters.setMasterState(masterid=7, active=False)
self.assertFalse(deactivated)
masterdict = yield self.db.masters.getMaster(7)
self.assertEqual(
masterdict,
masters.MasterModel(id=7, name='master-7', active=False, last_active=OTHERTIME_DT),
)
@defer.inlineCallbacks
def test_getMaster(self):
yield self.insert_test_data([
fakedb.Master(id=7, active=0, last_active=SOMETIME),
])
masterdict = yield self.db.masters.getMaster(7)
self.assertIsInstance(masterdict, masters.MasterModel)
self.assertEqual(
masterdict,
masters.MasterModel(id=7, name='master-7', active=False, last_active=SOMETIME_DT),
)
@defer.inlineCallbacks
def test_getMaster_missing(self):
masterdict = yield self.db.masters.getMaster(7)
self.assertEqual(masterdict, None)
@defer.inlineCallbacks
def test_getMasters(self):
yield self.insert_test_data([
fakedb.Master(id=7, active=0, last_active=SOMETIME),
fakedb.Master(id=8, active=1, last_active=OTHERTIME),
])
masterlist = yield self.db.masters.getMasters()
for masterdict in masterlist:
self.assertIsInstance(masterdict, masters.MasterModel)
def masterKey(master):
return master.id
expected = sorted(
[
masters.MasterModel(id=7, name='master-7', active=0, last_active=SOMETIME_DT),
masters.MasterModel(id=8, name='master-8', active=1, last_active=OTHERTIME_DT),
],
key=masterKey,
)
self.assertEqual(sorted(masterlist, key=masterKey), expected)
class RealTests(Tests):
# tests that only "real" implementations will pass
@defer.inlineCallbacks
def test_setMasterState_false_deletes_links(self):
yield self.insert_test_data([
fakedb.Master(id=7, name='some:master', active=1, last_active=OTHERTIME),
fakedb.Scheduler(id=21),
fakedb.SchedulerMaster(schedulerid=21, masterid=7),
])
deactivated = yield self.db.masters.setMasterState(masterid=7, active=False)
self.assertTrue(deactivated)
# check that the scheduler_masters row was deleted
def thd(conn):
tbl = self.db.model.scheduler_masters
self.assertEqual(conn.execute(tbl.select()).fetchall(), [])
yield self.db.pool.do(thd)
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=['masters', 'schedulers', 'scheduler_masters']
)
self.reactor.advance(SOMETIME)
self.db.masters = masters.MastersConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 7,993 | Python | .py | 185 | 35.102703 | 98 | 0.679959 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,411 | test_test_result_sets.py | buildbot_buildbot/master/buildbot/test/unit/db/test_test_result_sets.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import test_result_sets
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
class Tests(interfaces.InterfaceTests):
common_data = [
fakedb.Worker(id=47, name='linux'),
fakedb.Buildset(id=20),
fakedb.Builder(id=88, name='b1'),
fakedb.Builder(id=89, name='b2'),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=88),
fakedb.BuildRequest(id=42, buildsetid=20, builderid=88),
fakedb.BuildRequest(id=43, buildsetid=20, builderid=88),
fakedb.Master(id=88),
fakedb.Build(id=30, buildrequestid=41, number=7, masterid=88, builderid=88, workerid=47),
fakedb.Build(id=31, buildrequestid=42, number=8, masterid=88, builderid=88, workerid=47),
fakedb.Build(id=40, buildrequestid=43, number=9, masterid=88, builderid=89, workerid=47),
fakedb.Step(id=131, number=231, name='step231', buildid=30),
fakedb.Step(id=132, number=232, name='step232', buildid=30),
fakedb.Step(id=141, number=241, name='step241', buildid=31),
fakedb.Step(id=142, number=242, name='step242', buildid=40),
]
common_test_result_set_data = [
fakedb.TestResultSet(
id=91,
builderid=88,
buildid=30,
stepid=131,
description='desc1',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=0,
),
fakedb.TestResultSet(
id=92,
builderid=88,
buildid=30,
stepid=131,
description='desc2',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=1,
),
]
def test_signature_add_test_result_set(self):
@self.assertArgSpecMatches(self.db.test_result_sets.addTestResultSet)
def addTestResultSet(self, builderid, buildid, stepid, description, category, value_unit):
pass
def test_signature_get_test_result_set(self):
@self.assertArgSpecMatches(self.db.test_result_sets.getTestResultSet)
def getTestResultSet(self, test_result_setid):
pass
def test_signature_get_test_result_sets(self):
@self.assertArgSpecMatches(self.db.test_result_sets.getTestResultSets)
def getTestResultSets(
self, builderid, buildid=None, stepid=None, complete=None, result_spec=None
):
pass
def test_signature_complete_test_result_set(self):
@self.assertArgSpecMatches(self.db.test_result_sets.completeTestResultSet)
def completeTestResultSet(self, test_result_setid, tests_passed=None, tests_failed=None):
pass
@defer.inlineCallbacks
def test_add_set_get_set(self):
yield self.insert_test_data(self.common_data)
set_id = yield self.db.test_result_sets.addTestResultSet(
builderid=88,
buildid=30,
stepid=131,
description='desc',
category='cat',
value_unit='ms',
)
set_dict = yield self.db.test_result_sets.getTestResultSet(set_id)
self.assertIsInstance(set_dict, test_result_sets.TestResultSetModel)
self.assertEqual(
set_dict,
test_result_sets.TestResultSetModel(
id=set_id,
builderid=88,
buildid=30,
stepid=131,
description='desc',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=False,
),
)
@defer.inlineCallbacks
def test_get_sets(self):
yield self.insert_test_data([
*self.common_data,
fakedb.TestResultSet(
id=91,
builderid=88,
buildid=30,
stepid=131,
description='desc1',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=0,
),
fakedb.TestResultSet(
id=92,
builderid=89,
buildid=40,
stepid=142,
description='desc2',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=1,
),
fakedb.TestResultSet(
id=93,
builderid=88,
buildid=31,
stepid=141,
description='desc3',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=1,
),
fakedb.TestResultSet(
id=94,
builderid=88,
buildid=30,
stepid=132,
description='desc4',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=1,
),
fakedb.TestResultSet(
id=95,
builderid=88,
buildid=30,
stepid=131,
description='desc4',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=0,
),
])
set_dicts = yield self.db.test_result_sets.getTestResultSets(builderid=88)
self.assertEqual([d.id for d in set_dicts], [91, 93, 94, 95])
for d in set_dicts:
self.assertIsInstance(d, test_result_sets.TestResultSetModel)
set_dicts = yield self.db.test_result_sets.getTestResultSets(builderid=89)
self.assertEqual([d.id for d in set_dicts], [92])
set_dicts = yield self.db.test_result_sets.getTestResultSets(builderid=88, buildid=30)
self.assertEqual([d.id for d in set_dicts], [91, 94, 95])
set_dicts = yield self.db.test_result_sets.getTestResultSets(builderid=88, buildid=31)
self.assertEqual([d.id for d in set_dicts], [93])
set_dicts = yield self.db.test_result_sets.getTestResultSets(builderid=88, stepid=131)
self.assertEqual([d.id for d in set_dicts], [91, 95])
set_dicts = yield self.db.test_result_sets.getTestResultSets(builderid=88, stepid=132)
self.assertEqual([d.id for d in set_dicts], [94])
set_dicts = yield self.db.test_result_sets.getTestResultSets(builderid=88, complete=True)
self.assertEqual([d.id for d in set_dicts], [93, 94])
set_dicts = yield self.db.test_result_sets.getTestResultSets(builderid=88, complete=False)
self.assertEqual([d.id for d in set_dicts], [91, 95])
@defer.inlineCallbacks
def test_get_set_from_data(self):
yield self.insert_test_data(self.common_data + self.common_test_result_set_data)
set_dict = yield self.db.test_result_sets.getTestResultSet(91)
self.assertEqual(
set_dict,
test_result_sets.TestResultSetModel(
id=91,
builderid=88,
buildid=30,
stepid=131,
description='desc1',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=False,
),
)
@defer.inlineCallbacks
def test_get_non_existing_set(self):
set_dict = yield self.db.test_result_sets.getTestResultSet(91)
self.assertEqual(set_dict, None)
@defer.inlineCallbacks
def test_complete_already_completed_set(self):
yield self.insert_test_data(self.common_data + self.common_test_result_set_data)
with self.assertRaises(test_result_sets.TestResultSetAlreadyCompleted):
yield self.db.test_result_sets.completeTestResultSet(92)
self.flushLoggedErrors(test_result_sets.TestResultSetAlreadyCompleted)
@defer.inlineCallbacks
def test_complete_set_with_test_counts(self):
yield self.insert_test_data(self.common_data + self.common_test_result_set_data)
yield self.db.test_result_sets.completeTestResultSet(91, tests_passed=12, tests_failed=2)
set_dict = yield self.db.test_result_sets.getTestResultSet(91)
self.assertEqual(
set_dict,
test_result_sets.TestResultSetModel(
id=91,
builderid=88,
buildid=30,
stepid=131,
description='desc1',
category='cat',
value_unit='ms',
tests_failed=2,
tests_passed=12,
complete=True,
),
)
@defer.inlineCallbacks
def test_complete_set_without_test_counts(self):
yield self.insert_test_data(self.common_data + self.common_test_result_set_data)
yield self.db.test_result_sets.completeTestResultSet(91)
set_dict = yield self.db.test_result_sets.getTestResultSet(91)
self.assertEqual(
set_dict,
test_result_sets.TestResultSetModel(
id=91,
builderid=88,
buildid=30,
stepid=131,
description='desc1',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=True,
),
)
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, Tests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'steps',
'builds',
'builders',
'masters',
'buildrequests',
'buildsets',
'workers',
'test_result_sets',
"projects",
]
)
self.db.test_result_sets = test_result_sets.TestResultSetsConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 11,234 | Python | .py | 281 | 28.220641 | 98 | 0.582189 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,412 | test_projects.py | buildbot_buildbot/master/buildbot/test/unit/db/test_projects.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import projects
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
def project_key(builder):
return builder.id
class Tests(interfaces.InterfaceTests):
def test_signature_find_project_id(self):
@self.assertArgSpecMatches(self.db.projects.find_project_id)
def find_project_id(self, name, auto_create=True):
pass
def test_signature_get_project(self):
@self.assertArgSpecMatches(self.db.projects.get_project)
def get_project(self, projectid):
pass
def test_signature_get_projects(self):
@self.assertArgSpecMatches(self.db.projects.get_projects)
def get_projects(self):
pass
def test_signature_update_project_info(self):
@self.assertArgSpecMatches(self.db.projects.update_project_info)
def update_project_info(
self,
projectid,
slug,
description,
description_format,
description_html,
):
pass
@defer.inlineCallbacks
def test_update_project_info(self):
yield self.insert_test_data([
fakedb.Project(id=7, name='fake_project7'),
])
yield self.db.projects.update_project_info(
7, "slug7", "project7 desc", "format", "html desc"
)
dbdict = yield self.db.projects.get_project(7)
self.assertIsInstance(dbdict, projects.ProjectModel)
self.assertEqual(
dbdict,
projects.ProjectModel(
id=7,
name="fake_project7",
slug="slug7",
description="project7 desc",
description_format="format",
description_html="html desc",
),
)
@defer.inlineCallbacks
def test_find_project_id_new(self):
id = yield self.db.projects.find_project_id('fake_project')
dbdict = yield self.db.projects.get_project(id)
self.assertEqual(
dbdict,
projects.ProjectModel(
id=id,
name="fake_project",
slug="fake_project",
description=None,
description_format=None,
description_html=None,
),
)
@defer.inlineCallbacks
def test_find_project_id_new_no_auto_create(self):
id = yield self.db.projects.find_project_id('fake_project', auto_create=False)
self.assertIsNone(id)
@defer.inlineCallbacks
def test_find_project_id_exists(self):
yield self.insert_test_data([
fakedb.Project(id=7, name='fake_project'),
])
id = yield self.db.projects.find_project_id('fake_project')
self.assertEqual(id, 7)
@defer.inlineCallbacks
def test_get_project(self):
yield self.insert_test_data([
fakedb.Project(id=7, name='fake_project'),
])
dbdict = yield self.db.projects.get_project(7)
self.assertIsInstance(dbdict, projects.ProjectModel)
self.assertEqual(
dbdict,
projects.ProjectModel(
id=7,
name="fake_project",
slug="fake_project",
description=None,
description_format=None,
description_html=None,
),
)
@defer.inlineCallbacks
def test_get_project_missing(self):
dbdict = yield self.db.projects.get_project(7)
self.assertIsNone(dbdict)
@defer.inlineCallbacks
def test_get_projects(self):
yield self.insert_test_data([
fakedb.Project(id=7, name="fake_project7"),
fakedb.Project(id=8, name="fake_project8"),
fakedb.Project(id=9, name="fake_project9"),
])
dblist = yield self.db.projects.get_projects()
for dbdict in dblist:
self.assertIsInstance(dbdict, projects.ProjectModel)
self.assertEqual(
sorted(dblist, key=project_key),
sorted(
[
projects.ProjectModel(
id=7,
name="fake_project7",
slug="fake_project7",
description=None,
description_format=None,
description_html=None,
),
projects.ProjectModel(
id=8,
name="fake_project8",
slug="fake_project8",
description=None,
description_format=None,
description_html=None,
),
projects.ProjectModel(
id=9,
name="fake_project9",
slug="fake_project9",
description=None,
description_format=None,
description_html=None,
),
],
key=project_key,
),
)
@defer.inlineCallbacks
def test_get_projects_empty(self):
dblist = yield self.db.projects.get_projects()
self.assertEqual(dblist, [])
@defer.inlineCallbacks
def test_get_active_projects(self):
yield self.insert_test_data([
fakedb.Project(id=1, name='fake_project1'),
fakedb.Project(id=2, name='fake_project2'),
fakedb.Project(id=3, name='fake_project3'),
fakedb.Master(id=100),
fakedb.Builder(id=200, name="builder_200", projectid=2),
fakedb.Builder(id=201, name="builder_201", projectid=3),
fakedb.BuilderMaster(id=300, builderid=200, masterid=100),
])
dblist = yield self.db.projects.get_active_projects()
for dbdict in dblist:
self.assertIsInstance(dbdict, projects.ProjectModel)
self.assertEqual(
dblist,
[
projects.ProjectModel(
id=2,
name="fake_project2",
slug="fake_project2",
description=None,
description_format=None,
description_html=None,
)
],
)
class RealTests(Tests):
# tests that only "real" implementations will pass
pass
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=["projects", "builders", "masters", "builder_masters"]
)
self.db.projects = projects.ProjectsConnectorComponent(self.db)
self.master = self.db.master
self.master.db = self.db
def tearDown(self):
return self.tearDownConnectorComponent()
| 7,759 | Python | .py | 202 | 26.905941 | 92 | 0.583189 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,413 | test_base.py | buildbot_buildbot/master/buildbot/test/unit/db/test_base.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
import hashlib
from typing import TYPE_CHECKING
from unittest import mock
import sqlalchemy as sa
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import base
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.util import sautils
if TYPE_CHECKING:
from sqlalchemy.future.engine import Connection
class TestBase(unittest.TestCase):
def setUp(self):
meta = sa.MetaData()
self.tbl = sautils.Table(
'tbl', meta, sa.Column('str32', sa.String(length=32)), sa.Column('txt', sa.Text)
)
self.db = mock.Mock()
self.db.pool.engine.dialect.name = 'mysql'
self.comp = base.DBConnectorComponent(self.db)
def test_checkLength_ok(self):
self.comp.checkLength(self.tbl.c.str32, "short string")
def test_checkLength_long(self):
with self.assertRaises(RuntimeError):
self.comp.checkLength(self.tbl.c.str32, ("long string" * 5))
def test_ensureLength_ok(self):
v = self.comp.ensureLength(self.tbl.c.str32, "short string")
self.assertEqual(v, "short string")
def test_ensureLength_long(self):
v = self.comp.ensureLength(self.tbl.c.str32, "short string" * 5)
self.assertEqual(v, "short stringshordacf5a81f8ae3873")
self.comp.checkLength(self.tbl.c.str32, v)
def test_checkLength_text(self):
with self.assertRaises(AssertionError):
self.comp.checkLength(self.tbl.c.txt, ("long string" * 5))
def test_checkLength_long_not_mysql(self):
self.db.pool.engine.dialect.name = 'sqlite'
self.comp.checkLength(self.tbl.c.str32, "long string" * 5)
# run that again since the method gets stubbed out
self.comp.checkLength(self.tbl.c.str32, "long string" * 5)
class TestBaseAsConnectorComponent(unittest.TestCase, connector_component.ConnectorComponentMixin):
@defer.inlineCallbacks
def setUp(self):
# this co-opts the masters table to test findSomethingId
yield self.setUpConnectorComponent(table_names=['masters'])
self.db.base = base.DBConnectorComponent(self.db)
@defer.inlineCallbacks
def test_findSomethingId_race(self):
tbl = self.db.model.masters
hash = hashlib.sha1(b'somemaster').hexdigest()
def race_thd(conn: Connection):
conn.execute(
tbl.insert().values(
id=5, name='somemaster', name_hash=hash, active=1, last_active=1
)
)
conn.commit()
id = yield self.db.base.findSomethingId(
tbl=self.db.model.masters,
whereclause=(tbl.c.name_hash == hash),
insert_values={
"name": "somemaster",
"name_hash": hash,
"active": 1,
"last_active": 1,
},
_race_hook=race_thd,
)
self.assertEqual(id, 5)
@defer.inlineCallbacks
def test_findSomethingId_new(self):
tbl = self.db.model.masters
hash = hashlib.sha1(b'somemaster').hexdigest()
id = yield self.db.base.findSomethingId(
tbl=self.db.model.masters,
whereclause=(tbl.c.name_hash == hash),
insert_values={"name": 'somemaster', "name_hash": hash, "active": 1, "last_active": 1},
)
self.assertEqual(id, 1)
@defer.inlineCallbacks
def test_findSomethingId_existing(self):
tbl = self.db.model.masters
hash = hashlib.sha1(b'somemaster').hexdigest()
yield self.insert_test_data([
fakedb.Master(id=7, name='somemaster', name_hash=hash),
])
id = yield self.db.base.findSomethingId(
tbl=self.db.model.masters,
whereclause=(tbl.c.name_hash == hash),
insert_values={"name": 'somemaster', "name_hash": hash, "active": 1, "last_active": 1},
)
self.assertEqual(id, 7)
@defer.inlineCallbacks
def test_findSomethingId_new_noCreate(self):
tbl = self.db.model.masters
hash = hashlib.sha1(b'somemaster').hexdigest()
id = yield self.db.base.findSomethingId(
tbl=self.db.model.masters,
whereclause=(tbl.c.name_hash == hash),
insert_values={"name": 'somemaster', "name_hash": hash, "active": 1, "last_active": 1},
autoCreate=False,
)
self.assertEqual(id, None)
class TestCachedDecorator(unittest.TestCase):
def setUp(self):
# set this to True to check that cache.get isn't called (for
# no_cache=1)
self.cache_get_raises_exception = False
class TestConnectorComponent(base.DBConnectorComponent):
invocations = None
@base.cached("mycache")
def getThing(self, key):
if self.invocations is None:
self.invocations = []
self.invocations.append(key)
return defer.succeed(key * 2)
def get_cache(self, cache_name, miss_fn):
self.assertEqual(cache_name, "mycache")
cache = mock.Mock(name="mycache")
if self.cache_get_raises_exception:
def ex(key):
raise RuntimeError("cache.get called unexpectedly")
cache.get = ex
else:
cache.get = miss_fn
return cache
# tests
@defer.inlineCallbacks
def test_cached(self):
# attach it to the connector
connector = mock.Mock(name="connector")
connector.master.caches.get_cache = self.get_cache
# build an instance
comp = self.TestConnectorComponent(connector)
# test it twice (to test an implementation detail)
res1 = yield comp.getThing("foo")
res2 = yield comp.getThing("bar")
self.assertEqual((res1, res2, comp.invocations), ('foofoo', 'barbar', ['foo', 'bar']))
@defer.inlineCallbacks
def test_cached_no_cache(self):
# attach it to the connector
connector = mock.Mock(name="connector")
connector.master.caches.get_cache = self.get_cache
self.cache_get_raises_exception = True
# build an instance
comp = self.TestConnectorComponent(connector)
yield comp.getThing("foo", no_cache=1)
| 7,020 | Python | .py | 163 | 34.730061 | 99 | 0.65102 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,414 | test_users.py | buildbot_buildbot/master/buildbot/test/unit/db/test_users.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import sqlalchemy
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import users
from buildbot.test import fakedb
from buildbot.test.util import connector_component
class TestUsersConnectorComponent(connector_component.ConnectorComponentMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'users',
'users_info',
'changes',
'change_users',
'sourcestamps',
'patches',
]
)
self.db.users = users.UsersConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
# sample user data
user1_rows = [
fakedb.User(uid=1, identifier='soap'),
fakedb.UserInfo(uid=1, attr_type='IPv9', attr_data='0578cc6.8db024'),
]
user2_rows = [
fakedb.User(uid=2, identifier='lye'),
fakedb.UserInfo(uid=2, attr_type='git', attr_data='Tyler Durden <[email protected]>'),
fakedb.UserInfo(uid=2, attr_type='irc', attr_data='durden'),
]
user3_rows = [fakedb.User(uid=3, identifier='marla', bb_username='marla', bb_password='cancer')]
user1_model = users.UserModel(
uid=1,
identifier='soap',
bb_username=None,
bb_password=None,
attributes={
'IPv9': '0578cc6.8db024',
},
)
user2_model = users.UserModel(
uid=2,
identifier='lye',
bb_username=None,
bb_password=None,
attributes={
'irc': 'durden',
'git': 'Tyler Durden <[email protected]>',
},
)
user3_model = users.UserModel(
uid=3,
identifier='marla',
bb_username='marla',
bb_password='cancer',
attributes={},
)
# tests
@defer.inlineCallbacks
def test_addUser_new(self):
uid = yield self.db.users.findUserByAttr(
identifier='soap', attr_type='subspace_net_handle', attr_data='Durden0924'
)
def thd(conn):
users_tbl = self.db.model.users
users_info_tbl = self.db.model.users_info
users = conn.execute(users_tbl.select()).fetchall()
infos = conn.execute(users_info_tbl.select()).fetchall()
self.assertEqual(len(users), 1)
self.assertEqual(users[0].uid, uid)
self.assertEqual(users[0].identifier, 'soap')
self.assertEqual(len(infos), 1)
self.assertEqual(infos[0].uid, uid)
self.assertEqual(infos[0].attr_type, 'subspace_net_handle')
self.assertEqual(infos[0].attr_data, 'Durden0924')
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_addUser_existing(self):
yield self.insert_test_data(self.user1_rows)
uid = yield self.db.users.findUserByAttr(
identifier='soapy', attr_type='IPv9', attr_data='0578cc6.8db024'
)
self.assertEqual(uid, 1)
def thd(conn):
users_tbl = self.db.model.users
users_info_tbl = self.db.model.users_info
users = conn.execute(users_tbl.select()).fetchall()
infos = conn.execute(users_info_tbl.select()).fetchall()
self.assertEqual(len(users), 1)
self.assertEqual(users[0].uid, uid)
self.assertEqual(users[0].identifier, 'soap') # not changed!
self.assertEqual(len(infos), 1)
self.assertEqual(infos[0].uid, uid)
self.assertEqual(infos[0].attr_type, 'IPv9')
self.assertEqual(infos[0].attr_data, '0578cc6.8db024')
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_findUser_existing(self):
yield self.insert_test_data(self.user1_rows + self.user2_rows + self.user3_rows)
uid = yield self.db.users.findUserByAttr(
identifier='lye', attr_type='git', attr_data='Tyler Durden <[email protected]>'
)
self.assertEqual(uid, 2)
def thd(conn):
users_tbl = self.db.model.users
users_info_tbl = self.db.model.users_info
users = conn.execute(users_tbl.select()).fetchall()
infos = conn.execute(users_info_tbl.select()).fetchall()
self.assertEqual(
(sorted([tuple(u) for u in users]), sorted([tuple(i) for i in infos])),
(
[
(1, 'soap', None, None),
(2, 'lye', None, None),
(3, 'marla', 'marla', 'cancer'),
],
[
(1, 'IPv9', '0578cc6.8db024'),
(2, 'git', 'Tyler Durden <[email protected]>'),
(2, 'irc', 'durden'),
],
),
)
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_addUser_race(self):
def race_thd(conn):
# note that this assumes that both inserts can happen "at once".
# This is the case for DB engines that support transactions, but
# not for MySQL. so this test does not detect the potential MySQL
# failure, which will generally result in a spurious failure.
conn.execute(self.db.model.users.insert().values(uid=99, identifier='soap'))
conn.execute(
self.db.model.users_info.insert().values(
uid=99,
attr_type='subspace_net_handle',
attr_data='Durden0924',
)
)
conn.commit()
uid = yield self.db.users.findUserByAttr(
identifier='soap',
attr_type='subspace_net_handle',
attr_data='Durden0924',
_race_hook=race_thd,
)
self.assertEqual(uid, 99)
def thd(conn):
users_tbl = self.db.model.users
users_info_tbl = self.db.model.users_info
users = conn.execute(users_tbl.select()).fetchall()
infos = conn.execute(users_info_tbl.select()).fetchall()
self.assertEqual(len(users), 1)
self.assertEqual(users[0].uid, uid)
self.assertEqual(users[0].identifier, 'soap')
self.assertEqual(len(infos), 1)
self.assertEqual(infos[0].uid, uid)
self.assertEqual(infos[0].attr_type, 'subspace_net_handle')
self.assertEqual(infos[0].attr_data, 'Durden0924')
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_addUser_existing_identifier(self):
# see http://trac.buildbot.net/ticket/2587
yield self.insert_test_data(self.user1_rows)
uid = yield self.db.users.findUserByAttr(
identifier='soap', # same identifier
attr_type='IPv9',
attr_data='fffffff.ffffff',
) # different attr
# creates a new user
self.assertNotEqual(uid, 1)
def thd(conn):
users_tbl = self.db.model.users
users_info_tbl = self.db.model.users_info
users = conn.execute(users_tbl.select().order_by(users_tbl.c.identifier)).fetchall()
infos = conn.execute(
users_info_tbl.select().where(users_info_tbl.c.uid == uid)
).fetchall()
self.assertEqual(len(users), 2)
self.assertEqual(users[1].uid, uid)
self.assertEqual(users[1].identifier, 'soap_2') # unique'd
self.assertEqual(len(infos), 1)
self.assertEqual(infos[0].attr_type, 'IPv9')
self.assertEqual(infos[0].attr_data, 'fffffff.ffffff')
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_getUser(self):
yield self.insert_test_data(self.user1_rows)
usdict = yield self.db.users.getUser(1)
self.assertEqual(usdict, self.user1_model)
@defer.inlineCallbacks
def test_getUser_bb(self):
yield self.insert_test_data(self.user3_rows)
usdict = yield self.db.users.getUser(3)
self.assertEqual(usdict, self.user3_model)
@defer.inlineCallbacks
def test_getUser_multi_attr(self):
yield self.insert_test_data(self.user2_rows)
usdict = yield self.db.users.getUser(2)
self.assertEqual(usdict, self.user2_model)
@defer.inlineCallbacks
def test_getUser_no_match(self):
yield self.insert_test_data(self.user1_rows)
none = yield self.db.users.getUser(3)
self.assertEqual(none, None)
@defer.inlineCallbacks
def test_getUsers_none(self):
res = yield self.db.users.getUsers()
self.assertEqual(res, [])
@defer.inlineCallbacks
def test_getUsers(self):
yield self.insert_test_data(self.user1_rows)
res = yield self.db.users.getUsers()
self.assertEqual(res, [users.UserModel(uid=1, identifier='soap')])
@defer.inlineCallbacks
def test_getUsers_multiple(self):
yield self.insert_test_data(self.user1_rows + self.user2_rows)
res = yield self.db.users.getUsers()
self.assertEqual(
res,
[users.UserModel(uid=1, identifier='soap'), users.UserModel(uid=2, identifier='lye')],
)
@defer.inlineCallbacks
def test_getUserByUsername(self):
yield self.insert_test_data(self.user3_rows)
res = yield self.db.users.getUserByUsername("marla")
self.assertEqual(res, self.user3_model)
@defer.inlineCallbacks
def test_getUserByUsername_no_match(self):
yield self.insert_test_data(self.user3_rows)
none = yield self.db.users.getUserByUsername("tyler")
self.assertEqual(none, None)
@defer.inlineCallbacks
def test_updateUser_existing_type(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.updateUser(uid=1, attr_type='IPv9', attr_data='abcd.1234')
usdict = yield self.db.users.getUser(1)
self.assertEqual(usdict.attributes['IPv9'], 'abcd.1234')
self.assertEqual(usdict.identifier, 'soap') # no change
@defer.inlineCallbacks
def test_updateUser_new_type(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.updateUser(uid=1, attr_type='IPv4', attr_data='123.134.156.167')
usdict = yield self.db.users.getUser(1)
self.assertEqual(usdict.attributes['IPv4'], '123.134.156.167')
self.assertEqual(usdict.attributes['IPv9'], '0578cc6.8db024') # no change
self.assertEqual(usdict.identifier, 'soap') # no change
@defer.inlineCallbacks
def test_updateUser_identifier(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.updateUser(uid=1, identifier='lye')
usdict = yield self.db.users.getUser(1)
self.assertEqual(usdict.identifier, 'lye')
self.assertEqual(usdict.attributes['IPv9'], '0578cc6.8db024') # no change
@defer.inlineCallbacks
def test_updateUser_bb(self):
yield self.insert_test_data(self.user3_rows)
yield self.db.users.updateUser(uid=3, bb_username='boss', bb_password='fired')
usdict = yield self.db.users.getUser(3)
self.assertEqual(usdict.bb_username, 'boss')
self.assertEqual(usdict.bb_password, 'fired')
self.assertEqual(usdict.identifier, 'marla') # no change
@defer.inlineCallbacks
def test_updateUser_all(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.updateUser(
uid=1,
identifier='lye',
bb_username='marla',
bb_password='cancer',
attr_type='IPv4',
attr_data='123.134.156.167',
)
usdict = yield self.db.users.getUser(1)
self.assertEqual(
usdict,
users.UserModel(
uid=1,
identifier='lye',
bb_username='marla',
bb_password='cancer',
attributes={
'IPv4': '123.134.156.167',
'IPv9': '0578cc6.8db024', # no change
},
),
)
@defer.inlineCallbacks
def test_updateUser_race(self):
# called from the db thread, this opens a *new* connection (to avoid
# the existing transaction) and executes a conflicting insert in that
# connection. This will cause the insert in the db method to fail, and
# the data in this insert (8.8.8.8) will appear below.
race_condition_committed = []
if (
self.db.pool.engine.dialect.name == 'sqlite'
and self.db.pool.engine.url.database not in [None, ':memory:']
):
# It's not easy to work with file-based SQLite via multiple
# connections, because SQLAlchemy (in it's default configuration)
# locks file during working session.
# TODO: This probably can be supported.
raise unittest.SkipTest("It's hard to test race condition with not in-memory SQLite")
def race_thd(conn):
conn = self.db.pool.engine.connect()
try:
r = conn.execute(
self.db.model.users_info.insert().values(
uid=1, attr_type='IPv4', attr_data='8.8.8.8'
)
)
conn.commit()
r.close()
conn.close()
race_condition_committed.append(True)
except (sqlalchemy.exc.IntegrityError, sqlalchemy.exc.ProgrammingError):
# some engine (mysql innodb) will enforce lock until the transaction is over
race_condition_committed.append(False)
# scope variable, we modify a list so that modification is visible in parent scope
yield self.insert_test_data(self.user1_rows)
yield self.db.users.updateUser(
uid=1, attr_type='IPv4', attr_data='123.134.156.167', _race_hook=race_thd
)
if not race_condition_committed:
raise RuntimeError('programmer error: race condition was not called')
usdict = yield self.db.users.getUser(1)
self.assertEqual(usdict.identifier, 'soap')
if race_condition_committed[0] == self.db.has_native_upsert:
self.assertEqual(usdict.attributes['IPv4'], '123.134.156.167')
else:
self.assertEqual(usdict.attributes['IPv4'], '8.8.8.8')
self.assertEqual(usdict.attributes['IPv9'], '0578cc6.8db024') # no change
@defer.inlineCallbacks
def test_update_NoMatch_identifier(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.updateUser(uid=3, identifier='abcd')
usdict = yield self.db.users.getUser(1)
self.assertEqual(usdict.identifier, 'soap') # no change
@defer.inlineCallbacks
def test_update_NoMatch_attribute(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.updateUser(uid=3, attr_type='abcd', attr_data='efgh')
usdict = yield self.db.users.getUser(1)
self.assertEqual(usdict.attributes['IPv9'], '0578cc6.8db024') # no change
@defer.inlineCallbacks
def test_update_NoMatch_bb(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.updateUser(uid=3, attr_type='marla', attr_data='cancer')
usdict = yield self.db.users.getUser(1)
self.assertEqual(usdict.attributes['IPv9'], '0578cc6.8db024') # no change
@defer.inlineCallbacks
def test_removeUser_uid(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.removeUser(1)
def thd(conn):
r = conn.execute(self.db.model.users.select())
r = r.fetchall()
self.assertEqual(len(r), 0)
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_removeNoMatch(self):
yield self.insert_test_data(self.user1_rows)
yield self.db.users.removeUser(uid=3)
@defer.inlineCallbacks
def test_identifierToUid_NoMatch(self):
res = yield self.db.users.identifierToUid(identifier="soap")
self.assertEqual(res, None)
@defer.inlineCallbacks
def test_identifierToUid_match(self):
yield self.insert_test_data(self.user1_rows)
res = yield self.db.users.identifierToUid(identifier="soap")
self.assertEqual(res, 1)
| 17,275 | Python | .py | 388 | 34.167526 | 100 | 0.616082 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,415 | test_workers.py | buildbot_buildbot/master/buildbot/test/unit/db/test_workers.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import workers
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
from buildbot.test.util import querylog
def workerKey(worker: workers.WorkerModel):
return worker.id
def configuredOnKey(worker: workers.BuilderMasterModel):
return (worker.builderid, worker.masterid)
class Tests(interfaces.InterfaceTests):
# common sample data
baseRows = [
fakedb.Master(id=10, name='m10'),
fakedb.Master(id=11, name='m11'),
fakedb.Builder(id=20, name='a'),
fakedb.Builder(id=21, name='b'),
fakedb.Builder(id=22, name='c'),
fakedb.Worker(id=30, name='zero'),
fakedb.Worker(id=31, name='one'),
]
multipleMasters = [
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.BuilderMaster(id=13, builderid=21, masterid=10),
fakedb.BuilderMaster(id=14, builderid=20, masterid=11),
fakedb.BuilderMaster(id=15, builderid=22, masterid=11),
fakedb.BuilderMaster(id=16, builderid=22, masterid=10),
fakedb.ConfiguredWorker(id=3012, workerid=30, buildermasterid=12),
fakedb.ConfiguredWorker(id=3013, workerid=30, buildermasterid=13),
fakedb.ConfiguredWorker(id=3014, workerid=30, buildermasterid=14),
fakedb.ConfiguredWorker(id=3114, workerid=31, buildermasterid=14),
fakedb.ConfiguredWorker(id=3115, workerid=31, buildermasterid=15),
fakedb.ConnectedWorker(id=3010, workerid=30, masterid=10),
fakedb.ConnectedWorker(id=3111, workerid=31, masterid=11),
]
# sample worker data, with id's avoiding the postgres id sequence
BOGUS_NAME = 'bogus'
W1_NAME = "w1"
W1_ID = 100
W1_INFO = {'a': 1}
worker1_rows = [
fakedb.Worker(id=W1_ID, name=W1_NAME, info=W1_INFO),
]
W2_NAME = "w2"
W2_ID = 200
W2_INFO = {'a': 1, 'b': 2}
worker2_rows = [
fakedb.Worker(id=W2_ID, name=W2_NAME, info=W2_INFO),
]
# tests
def test_signature_findWorkerId(self):
@self.assertArgSpecMatches(self.db.workers.findWorkerId)
def findWorkerId(self, name):
pass
def test_signature_getWorker(self):
@self.assertArgSpecMatches(self.db.workers.getWorker)
def getWorker(self, workerid=None, name=None, masterid=None, builderid=None):
pass
def test_signature_getWorkers(self):
@self.assertArgSpecMatches(self.db.workers.getWorkers)
def getWorkers(self, masterid=None, builderid=None, paused=None, graceful=None):
pass
def test_signature_workerConnected(self):
@self.assertArgSpecMatches(self.db.workers.workerConnected)
def workerConnected(self, workerid, masterid, workerinfo):
pass
def test_signature_workerDisconnected(self):
@self.assertArgSpecMatches(self.db.workers.workerDisconnected)
def workerDisconnected(self, workerid, masterid):
pass
def test_signature_workerConfigured(self):
@self.assertArgSpecMatches(self.db.workers.workerConfigured)
def workerConfigured(self, workerid, masterid, builderids):
pass
def test_signature_deconfigureAllWorkersForMaster(self):
@self.assertArgSpecMatches(self.db.workers.deconfigureAllWorkersForMaster)
def deconfigureAllWorkersForMaster(self, masterid):
pass
def test_signature_set_worker_paused(self):
@self.assertArgSpecMatches(self.db.workers.set_worker_paused)
def set_worker_paused(self, workerid, paused, pause_reason=None):
pass
def test_signature_set_worker_graceful(self):
@self.assertArgSpecMatches(self.db.workers.set_worker_graceful)
def set_worker_graceful(self, workerid, graceful):
pass
@defer.inlineCallbacks
def test_findWorkerId_insert(self):
id = yield self.db.workers.findWorkerId(name="xyz")
worker = yield self.db.workers.getWorker(workerid=id)
self.assertEqual(worker.name, 'xyz')
self.assertEqual(worker.workerinfo, {})
@defer.inlineCallbacks
def test_findWorkerId_existing(self):
yield self.insert_test_data(self.baseRows)
id = yield self.db.workers.findWorkerId(name="one")
self.assertEqual(id, 31)
@defer.inlineCallbacks
def test_getWorker_no_such(self):
yield self.insert_test_data(self.baseRows)
workerdict = yield self.db.workers.getWorker(workerid=99)
self.assertEqual(workerdict, None)
@defer.inlineCallbacks
def test_getWorker_by_name_no_such(self):
yield self.insert_test_data(self.baseRows)
workerdict = yield self.db.workers.getWorker(name='NOSUCH')
self.assertEqual(workerdict, None)
@defer.inlineCallbacks
def test_getWorker_not_configured(self):
yield self.insert_test_data(self.baseRows)
workerdict = yield self.db.workers.getWorker(workerid=30)
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
connected_to=[],
configured_on=[],
),
)
@defer.inlineCallbacks
def test_getWorker_connected_not_configured(self):
yield self.insert_test_data([
*self.baseRows,
# the worker is connected to this master, but not configured.
# weird, but the DB should represent it.
fakedb.Worker(id=32, name='two'),
fakedb.ConnectedWorker(workerid=32, masterid=11),
])
workerdict = yield self.db.workers.getWorker(workerid=32)
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=32,
name='two',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
connected_to=[11],
configured_on=[],
),
)
@defer.inlineCallbacks
def test_getWorker_multiple_connections(self):
yield self.insert_test_data([
*self.baseRows,
# the worker is connected to two masters at once.
# weird, but the DB should represent it.
fakedb.Worker(id=32, name='two'),
fakedb.ConnectedWorker(workerid=32, masterid=10),
fakedb.ConnectedWorker(workerid=32, masterid=11),
fakedb.BuilderMaster(id=24, builderid=20, masterid=10),
fakedb.BuilderMaster(id=25, builderid=20, masterid=11),
fakedb.ConfiguredWorker(workerid=32, buildermasterid=24),
fakedb.ConfiguredWorker(workerid=32, buildermasterid=25),
])
workerdict = yield self.db.workers.getWorker(workerid=32)
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=32,
name='two',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
connected_to=[10, 11],
configured_on=[
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=20, masterid=11),
],
),
)
@defer.inlineCallbacks
def test_getWorker_by_name_not_configured(self):
yield self.insert_test_data(self.baseRows)
workerdict = yield self.db.workers.getWorker(name='zero')
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
connected_to=[],
configured_on=[],
),
)
@defer.inlineCallbacks
def test_getWorker_not_connected(self):
yield self.insert_test_data([
*self.baseRows,
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.ConfiguredWorker(workerid=30, buildermasterid=12),
])
workerdict = yield self.db.workers.getWorker(workerid=30)
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=[workers.BuilderMasterModel(masterid=10, builderid=20)],
connected_to=[],
),
)
@defer.inlineCallbacks
def test_getWorker_connected(self):
yield self.insert_test_data([
*self.baseRows,
fakedb.BuilderMaster(id=12, builderid=20, masterid=10),
fakedb.ConfiguredWorker(workerid=30, buildermasterid=12),
fakedb.ConnectedWorker(workerid=30, masterid=10),
])
workerdict = yield self.db.workers.getWorker(workerid=30)
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=[workers.BuilderMasterModel(masterid=10, builderid=20)],
connected_to=[10],
),
)
@defer.inlineCallbacks
def test_getWorker_with_multiple_masters(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(workerid=30)
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = sorted(workerdict.configured_on, key=configuredOnKey)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(masterid=10, builderid=20),
workers.BuilderMasterModel(masterid=10, builderid=21),
workers.BuilderMasterModel(masterid=11, builderid=20),
],
key=configuredOnKey,
),
connected_to=[10],
),
)
@defer.inlineCallbacks
def test_getWorker_with_multiple_masters_builderid(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(workerid=30, builderid=20)
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = sorted(workerdict.configured_on, key=configuredOnKey)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=20, masterid=11),
],
key=configuredOnKey,
),
connected_to=[10],
),
)
@defer.inlineCallbacks
def test_getWorker_with_multiple_masters_masterid(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(workerid=30, masterid=11)
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=[
workers.BuilderMasterModel(builderid=20, masterid=11),
],
connected_to=[],
),
)
@defer.inlineCallbacks
def test_getWorker_with_multiple_masters_builderid_masterid(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(workerid=30, builderid=20, masterid=11)
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=[
workers.BuilderMasterModel(builderid=20, masterid=11),
],
connected_to=[],
),
)
@defer.inlineCallbacks
def test_getWorker_by_name_with_multiple_masters_builderid_masterid(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdict = yield self.db.workers.getWorker(name='zero', builderid=20, masterid=11)
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
workerdict,
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=[
workers.BuilderMasterModel(masterid=11, builderid=20),
],
connected_to=[],
),
)
@defer.inlineCallbacks
def test_getWorkers_no_config(self):
yield self.insert_test_data(self.baseRows)
workerdicts = yield self.db.workers.getWorkers()
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
self.assertEqual(
sorted(workerdicts, key=workerKey),
sorted(
[
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=[],
connected_to=[],
),
workers.WorkerModel(
id=31,
name='one',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=[],
connected_to=[],
),
],
key=workerKey,
),
)
@defer.inlineCallbacks
def test_getWorkers_with_config(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers()
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = sorted(workerdict.configured_on, key=configuredOnKey)
self.assertEqual(
sorted(workerdicts, key=workerKey),
sorted(
[
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=21, masterid=10),
workers.BuilderMasterModel(builderid=20, masterid=11),
],
key=configuredOnKey,
),
connected_to=[10],
),
workers.WorkerModel(
id=31,
name='one',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=11),
workers.BuilderMasterModel(builderid=22, masterid=11),
],
key=configuredOnKey,
),
connected_to=[11],
),
],
key=workerKey,
),
)
@defer.inlineCallbacks
def test_getWorkers_empty(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(masterid=11, builderid=21)
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = sorted(workerdict.configured_on, key=configuredOnKey)
self.assertEqual(sorted(workerdicts, key=workerKey), [])
@defer.inlineCallbacks
def test_getWorkers_with_config_builderid(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(builderid=20)
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = sorted(workerdict.configured_on, key=configuredOnKey)
self.assertEqual(
sorted(workerdicts, key=workerKey),
sorted(
[
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=20, masterid=11),
],
key=configuredOnKey,
),
connected_to=[10],
),
workers.WorkerModel(
id=31,
name='one',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=11),
],
key=configuredOnKey,
),
connected_to=[11],
),
],
key=workerKey,
),
)
@defer.inlineCallbacks
def test_getWorkers_with_config_masterid_10(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(masterid=10)
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = sorted(workerdict.configured_on, key=configuredOnKey)
self.assertEqual(
sorted(workerdicts, key=workerKey),
sorted(
[
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=21, masterid=10),
],
key=configuredOnKey,
),
connected_to=[10],
),
],
key=workerKey,
),
)
@defer.inlineCallbacks
def test_getWorkers_with_config_masterid_11(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(masterid=11)
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = sorted(workerdict.configured_on, key=configuredOnKey)
self.assertEqual(
sorted(workerdicts, key=workerKey),
sorted(
[
workers.WorkerModel(
id=30,
name='zero',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=11),
],
key=configuredOnKey,
),
connected_to=[],
),
workers.WorkerModel(
id=31,
name='one',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=11),
workers.BuilderMasterModel(builderid=22, masterid=11),
],
key=configuredOnKey,
),
connected_to=[11],
),
],
key=workerKey,
),
)
@defer.inlineCallbacks
def test_getWorkers_with_config_masterid_11_builderid_22(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
workerdicts = yield self.db.workers.getWorkers(masterid=11, builderid=22)
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = sorted(workerdict.configured_on, key=configuredOnKey)
self.assertEqual(
sorted(workerdicts, key=workerKey),
sorted(
[
workers.WorkerModel(
id=31,
name='one',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=False,
configured_on=sorted(
[
workers.BuilderMasterModel(builderid=22, masterid=11),
],
key=configuredOnKey,
),
connected_to=[11],
),
],
key=workerKey,
),
)
@defer.inlineCallbacks
def test_getWorkers_with_paused(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
yield self.db.workers.set_worker_paused(31, paused=True, pause_reason="reason")
yield self.db.workers.set_worker_graceful(31, graceful=False)
workerdicts = yield self.db.workers.getWorkers(paused=True)
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = []
self.assertEqual(
workerdicts,
[
workers.WorkerModel(
id=31,
name='one',
workerinfo={'a': 'b'},
paused=True,
pause_reason="reason",
graceful=False,
configured_on=[],
connected_to=[11],
),
],
)
@defer.inlineCallbacks
def test_getWorkers_with_graceful(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
yield self.db.workers.set_worker_paused(31, paused=False)
yield self.db.workers.set_worker_graceful(31, graceful=True)
workerdicts = yield self.db.workers.getWorkers(graceful=True)
for workerdict in workerdicts:
self.assertIsInstance(workerdict, workers.WorkerModel)
workerdict.configured_on = []
self.assertEqual(
workerdicts,
[
workers.WorkerModel(
id=31,
name='one',
workerinfo={'a': 'b'},
paused=False,
pause_reason=None,
graceful=True,
configured_on=[],
connected_to=[11],
),
],
)
@defer.inlineCallbacks
def test_workerConnected_existing(self):
yield self.insert_test_data(self.baseRows + self.worker1_rows)
NEW_INFO = {'other': [1, 2, 3]}
yield self.db.workers.workerConnected(workerid=self.W1_ID, masterid=11, workerinfo=NEW_INFO)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(
w,
workers.WorkerModel(
id=self.W1_ID,
name=self.W1_NAME,
workerinfo=NEW_INFO,
paused=False,
pause_reason=None,
graceful=False,
configured_on=[],
connected_to=[11],
),
)
@defer.inlineCallbacks
def test_workerConnected_already_connected(self):
yield self.insert_test_data(
self.baseRows
+ self.worker1_rows
+ [
fakedb.ConnectedWorker(id=888, workerid=self.W1_ID, masterid=11),
]
)
yield self.db.workers.workerConnected(workerid=self.W1_ID, masterid=11, workerinfo={})
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(w.connected_to, [11])
@defer.inlineCallbacks
def test_workerDisconnected(self):
yield self.insert_test_data(
self.baseRows
+ self.worker1_rows
+ [
fakedb.ConnectedWorker(id=888, workerid=self.W1_ID, masterid=10),
fakedb.ConnectedWorker(id=889, workerid=self.W1_ID, masterid=11),
]
)
yield self.db.workers.workerDisconnected(workerid=self.W1_ID, masterid=11)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(w.connected_to, [10])
@defer.inlineCallbacks
def test_workerDisconnected_already_disconnected(self):
yield self.insert_test_data(self.baseRows + self.worker1_rows)
yield self.db.workers.workerDisconnected(workerid=self.W1_ID, masterid=11)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(w.connected_to, [])
@defer.inlineCallbacks
def test_set_worker_paused_existing(self):
yield self.insert_test_data(self.baseRows + self.worker1_rows)
yield self.db.workers.set_worker_paused(self.W1_ID, False, None)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(
w,
workers.WorkerModel(
id=self.W1_ID,
name=self.W1_NAME,
workerinfo=self.W1_INFO,
paused=False,
pause_reason=None,
graceful=False,
configured_on=[],
connected_to=[],
),
)
yield self.db.workers.set_worker_paused(self.W1_ID, True, "reason")
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(
w,
workers.WorkerModel(
id=self.W1_ID,
name=self.W1_NAME,
workerinfo=self.W1_INFO,
paused=True,
pause_reason="reason",
graceful=False,
configured_on=[],
connected_to=[],
),
)
@defer.inlineCallbacks
def test_set_worker_graceful_existing(self):
yield self.insert_test_data(self.baseRows + self.worker1_rows)
yield self.db.workers.set_worker_graceful(self.W1_ID, False)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(
w,
workers.WorkerModel(
id=self.W1_ID,
name=self.W1_NAME,
workerinfo=self.W1_INFO,
paused=False,
pause_reason=None,
graceful=False,
configured_on=[],
connected_to=[],
),
)
yield self.db.workers.set_worker_graceful(self.W1_ID, True)
w = yield self.db.workers.getWorker(self.W1_ID)
self.assertEqual(
w,
workers.WorkerModel(
id=self.W1_ID,
name=self.W1_NAME,
workerinfo=self.W1_INFO,
paused=False,
pause_reason=None,
graceful=True,
configured_on=[],
connected_to=[],
),
)
@defer.inlineCallbacks
def test_workerConfigured(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
# should remove builder 21, and add 22
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
yield self.db.workers.workerConfigured(workerid=30, masterid=10, builderids=[20, 22])
w = yield self.db.workers.getWorker(30)
self.assertEqual(
sorted(w.configured_on, key=configuredOnKey),
sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=11),
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=22, masterid=10),
],
key=configuredOnKey,
),
)
@defer.inlineCallbacks
def test_workerConfiguredTwice(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
# should remove builder 21, and add 22
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
yield self.db.workers.workerConfigured(workerid=30, masterid=10, builderids=[20, 22])
# configure again (should eat the duplicate insertion errors)
yield self.db.workers.workerConfigured(workerid=30, masterid=10, builderids=[20, 21, 22])
w = yield self.db.workers.getWorker(30)
x1 = sorted(w.configured_on, key=configuredOnKey)
x2 = sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=11),
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=21, masterid=10),
workers.BuilderMasterModel(builderid=22, masterid=10),
],
key=configuredOnKey,
)
self.assertEqual(x1, x2)
@defer.inlineCallbacks
def test_workerReConfigured(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
# should remove builder 21, and add 22
yield self.db.workers.workerConfigured(workerid=30, masterid=10, builderids=[20, 22])
w = yield self.db.workers.getWorker(30)
w.configured_on = sorted(w.configured_on, key=configuredOnKey)
self.assertEqual(
w.configured_on,
sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=11),
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=22, masterid=10),
],
key=configuredOnKey,
),
)
@defer.inlineCallbacks
def test_workerReConfigured_should_not_affect_other_worker(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
# should remove all the builders in master 11
yield self.db.workers.workerConfigured(workerid=30, masterid=11, builderids=[])
w = yield self.db.workers.getWorker(30)
x1 = sorted(w.configured_on, key=configuredOnKey)
x2 = sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=10),
workers.BuilderMasterModel(builderid=21, masterid=10),
],
key=configuredOnKey,
)
self.assertEqual(x1, x2)
# ensure worker 31 is not affected (see GitHub issue#3392)
w = yield self.db.workers.getWorker(31)
x1 = sorted(w.configured_on, key=configuredOnKey)
x2 = sorted(
[
workers.BuilderMasterModel(builderid=20, masterid=11),
workers.BuilderMasterModel(builderid=22, masterid=11),
],
key=configuredOnKey,
)
self.assertEqual(x1, x2)
@defer.inlineCallbacks
def test_workerUnconfigured(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
# should remove all builders from master 10
yield self.db.workers.workerConfigured(workerid=30, masterid=10, builderids=[])
w = yield self.db.workers.getWorker(30)
w.configured_on = sorted(w.configured_on, key=configuredOnKey)
expected = sorted(
[workers.BuilderMasterModel(builderid=20, masterid=11)], key=configuredOnKey
)
self.assertEqual(w.configured_on, expected)
@defer.inlineCallbacks
def test_nothingConfigured(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
# should remove builder 21, and add 22
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
yield self.db.workers.workerConfigured(workerid=30, masterid=10, builderids=[])
# should only keep builder for master 11
w = yield self.db.workers.getWorker(30)
self.assertEqual(
sorted(w.configured_on), sorted([workers.BuilderMasterModel(builderid=20, masterid=11)])
)
@defer.inlineCallbacks
def test_deconfiguredAllWorkers(self):
yield self.insert_test_data(self.baseRows + self.multipleMasters)
res = yield self.db.workers.getWorkers(masterid=11)
self.assertEqual(len(res), 2)
# should remove all worker configured for masterid 11
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=11)
res = yield self.db.workers.getWorkers(masterid=11)
self.assertEqual(len(res), 0)
class RealTests(Tests):
# tests that only "real" implementations will pass
pass
class TestRealDB(
unittest.TestCase,
connector_component.ConnectorComponentMixin,
RealTests,
querylog.SqliteMaxVariableMixin,
):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'workers',
'masters',
'projects',
'builders',
'builder_masters',
'connected_workers',
'configured_workers',
]
)
self.db.workers = workers.WorkersConnectorComponent(self.db)
@defer.inlineCallbacks
def test_workerConfiguredMany(self):
manyWorkers = (
[
fakedb.BuilderMaster(id=1000, builderid=20, masterid=10),
]
+ [fakedb.Worker(id=50 + n, name='zero' + str(n)) for n in range(1000)]
+ [
fakedb.ConfiguredWorker(id=n + 3000, workerid=50 + n, buildermasterid=1000)
for n in range(1000)
]
)
yield self.insert_test_data(self.baseRows + manyWorkers)
# should successfully remove all ConfiguredWorker rows
with self.assertNoMaxVariables():
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
w = yield self.db.workers.getWorker(30)
self.assertEqual(sorted(w.configured_on), [])
@defer.inlineCallbacks
def test_workerConfiguredManyBuilders(self):
manyWorkers = (
[fakedb.Builder(id=100 + n, name='a' + str(n)) for n in range(1000)]
+ [fakedb.Worker(id=50 + n, name='zero' + str(n)) for n in range(2000)]
+ [
fakedb.BuilderMaster(id=1000 + n, builderid=100 + n, masterid=10)
for n in range(1000)
]
+ [
fakedb.ConfiguredWorker(
id=n + 3000, workerid=50 + n, buildermasterid=int(1000 + n / 2)
)
for n in range(2000)
]
)
yield self.insert_test_data(self.baseRows + manyWorkers)
# should successfully remove all ConfiguredWorker rows
with self.assertNoMaxVariables():
yield self.db.workers.deconfigureAllWorkersForMaster(masterid=10)
w = yield self.db.workers.getWorker(30)
self.assertEqual(sorted(w.configured_on), [])
def tearDown(self):
return self.tearDownConnectorComponent()
| 39,730 | Python | .py | 955 | 27.864921 | 100 | 0.558099 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,416 | test_buildrequests.py | buildbot_buildbot/master/buildbot/test/unit/db/test_buildrequests.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import datetime
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import buildrequests
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import db
from buildbot.test.util import interfaces
from buildbot.util import UTC
from buildbot.util import epoch2datetime
class Tests(interfaces.InterfaceTests):
# test that the datetime translations are done correctly by specifying
# the epoch timestamp and datetime objects explicitly. These should
# pass regardless of the local timezone used while running tests!
CLAIMED_AT = datetime.datetime(1978, 6, 15, 12, 31, 15, tzinfo=UTC)
CLAIMED_AT_EPOCH = 266761875
SUBMITTED_AT = datetime.datetime(1979, 6, 15, 12, 31, 15, tzinfo=UTC)
SUBMITTED_AT_EPOCH = 298297875
COMPLETE_AT = datetime.datetime(1980, 6, 15, 12, 31, 15, tzinfo=UTC)
COMPLETE_AT_EPOCH = 329920275
BSID = 567
BLDRID1 = 890
BLDRID2 = 891
BLDRID3 = 893
MASTER_ID = "set in setUp"
OTHER_MASTER_ID = "set in setUp"
def setUpTests(self):
# set up a sourcestamp and buildset for use below
self.MASTER_ID = fakedb.FakeDBConnector.MASTER_ID
self.OTHER_MASTER_ID = self.MASTER_ID + 1111
self.db.master.masterid = self.MASTER_ID
return self.insert_test_data([
fakedb.SourceStamp(id=234),
fakedb.Master(id=self.MASTER_ID, name="fake master"),
fakedb.Master(id=self.OTHER_MASTER_ID, name="other"),
fakedb.Buildset(id=self.BSID),
fakedb.Builder(id=self.BLDRID1, name="builder1"),
fakedb.Builder(id=self.BLDRID2, name="builder2"),
fakedb.Builder(id=self.BLDRID3, name="builder3"),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID, sourcestampid=234),
])
# tests
@defer.inlineCallbacks
def test_getBuildRequest(self):
yield self.insert_test_data([
fakedb.BuildRequest(
id=44,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=75,
priority=7,
submitted_at=self.SUBMITTED_AT_EPOCH,
complete_at=self.COMPLETE_AT_EPOCH,
),
fakedb.BuildRequestClaim(
brid=44, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
])
brdict = yield self.db.buildrequests.getBuildRequest(44)
yield self.assertEqual(
brdict,
buildrequests.BuildRequestModel(
buildrequestid=44,
buildsetid=self.BSID,
builderid=self.BLDRID1,
buildername="builder1",
priority=7,
claimed_by_masterid=self.MASTER_ID,
complete=True,
results=75,
claimed_at=self.CLAIMED_AT,
submitted_at=self.SUBMITTED_AT,
complete_at=self.COMPLETE_AT,
waited_for=False,
),
)
@defer.inlineCallbacks
def test_getBuildRequest_missing(self):
brdict = yield self.db.buildrequests.getBuildRequest(44)
self.assertEqual(brdict, None)
@defer.inlineCallbacks
def do_test_getBuildRequests_claim_args(self, **kwargs):
expected = kwargs.pop('expected')
yield self.insert_test_data([
# 50: claimed by this master
fakedb.BuildRequest(id=50, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequestClaim(
brid=50, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 51: claimed by another master
fakedb.BuildRequest(id=51, buildsetid=self.BSID, builderid=self.BLDRID2),
fakedb.BuildRequestClaim(
brid=51, masterid=self.OTHER_MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 52: unclaimed
fakedb.BuildRequest(id=52, buildsetid=self.BSID, builderid=self.BLDRID1),
# 53: unclaimed but complete (should not appear for claimed=False)
fakedb.BuildRequest(id=53, buildsetid=self.BSID, builderid=self.BLDRID1, complete=1),
])
brlist = yield self.db.buildrequests.getBuildRequests(**kwargs)
self.assertEqual(sorted([br.buildrequestid for br in brlist]), sorted(expected))
def test_getBuildRequests_no_claimed_arg(self):
return self.do_test_getBuildRequests_claim_args(expected=[50, 51, 52, 53])
def test_getBuildRequests_claimed_mine(self):
return self.do_test_getBuildRequests_claim_args(claimed=self.MASTER_ID, expected=[50])
def test_getBuildRequests_claimed_true(self):
return self.do_test_getBuildRequests_claim_args(claimed=True, expected=[50, 51])
def test_getBuildRequests_unclaimed(self):
return self.do_test_getBuildRequests_claim_args(claimed=False, expected=[52])
@defer.inlineCallbacks
def do_test_getBuildRequests_buildername_arg(self, **kwargs):
expected = kwargs.pop('expected')
yield self.insert_test_data([
# 8: 'bb'
fakedb.BuildRequest(id=8, buildsetid=self.BSID, builderid=self.BLDRID1),
# 9: 'cc'
fakedb.BuildRequest(id=9, buildsetid=self.BSID, builderid=self.BLDRID2),
# 10: 'cc'
fakedb.BuildRequest(id=10, buildsetid=self.BSID, builderid=self.BLDRID2),
])
brlist = yield self.db.buildrequests.getBuildRequests(**kwargs)
self.assertEqual(sorted([br.buildrequestid for br in brlist]), sorted(expected))
@defer.inlineCallbacks
def do_test_getBuildRequests_complete_arg(self, **kwargs):
expected = kwargs.pop('expected')
yield self.insert_test_data([
# 70: incomplete
fakedb.BuildRequest(
id=70, buildsetid=self.BSID, builderid=self.BLDRID1, complete=0, complete_at=None
),
# 80: complete
fakedb.BuildRequest(
id=80,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
complete_at=self.COMPLETE_AT_EPOCH,
),
# 81: complete but no complete_at
fakedb.BuildRequest(
id=81, buildsetid=self.BSID, builderid=self.BLDRID1, complete=1, complete_at=0
),
# 82: complete_at set but complete is false, so not complete
fakedb.BuildRequest(
id=82,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=0,
complete_at=self.COMPLETE_AT_EPOCH,
),
])
brlist = yield self.db.buildrequests.getBuildRequests(**kwargs)
self.assertEqual(sorted([br.buildrequestid for br in brlist]), sorted(expected))
def test_getBuildRequests_complete_none(self):
return self.do_test_getBuildRequests_complete_arg(expected=[70, 80, 81, 82])
def test_getBuildRequests_complete_true(self):
return self.do_test_getBuildRequests_complete_arg(complete=True, expected=[80, 81])
def test_getBuildRequests_complete_false(self):
return self.do_test_getBuildRequests_complete_arg(complete=False, expected=[70, 82])
@defer.inlineCallbacks
def test_getBuildRequests_bsid_arg(self):
yield self.insert_test_data([
# the buildset that we are *not* looking for
fakedb.Buildset(id=self.BSID + 1),
fakedb.BuildRequest(
id=70, buildsetid=self.BSID, builderid=self.BLDRID1, complete=0, complete_at=None
),
fakedb.BuildRequest(
id=71,
buildsetid=self.BSID + 1,
builderid=self.BLDRID1,
complete=0,
complete_at=None,
),
fakedb.BuildRequest(
id=72, buildsetid=self.BSID, builderid=self.BLDRID1, complete=0, complete_at=None
),
])
brlist = yield self.db.buildrequests.getBuildRequests(bsid=self.BSID)
self.assertEqual(sorted([br.buildrequestid for br in brlist]), sorted([70, 72]))
@defer.inlineCallbacks
def test_getBuildRequests_combo(self):
yield self.insert_test_data([
# 44: everything we want
fakedb.BuildRequest(
id=44,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH,
),
fakedb.BuildRequestClaim(
brid=44, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 45: different builderid
fakedb.BuildRequest(
id=45,
buildsetid=self.BSID,
builderid=self.BLDRID2,
complete=1,
complete_at=self.COMPLETE_AT_EPOCH,
),
fakedb.BuildRequestClaim(
brid=45, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 46: incomplete
fakedb.BuildRequest(
id=46,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=0,
results=92,
complete_at=0,
),
fakedb.BuildRequestClaim(
brid=46, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 47: unclaimed
fakedb.BuildRequest(
id=47,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH,
),
# 48: claimed by other
fakedb.BuildRequest(
id=48,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH,
),
fakedb.BuildRequestClaim(
brid=48, masterid=self.OTHER_MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 49: different bsid
fakedb.Buildset(id=self.BSID + 1),
fakedb.BuildRequest(
id=49,
buildsetid=self.BSID + 1,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH,
),
fakedb.BuildRequestClaim(
brid=49, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
])
brlist = yield self.db.buildrequests.getBuildRequests(
builderid=self.BLDRID1, claimed=self.MASTER_ID, complete=True, bsid=self.BSID
)
self.assertEqual([br.buildrequestid for br in brlist], [44])
@defer.inlineCallbacks
def do_test_getBuildRequests_branch_arg(self, **kwargs):
expected = kwargs.pop('expected')
yield self.insert_test_data([
fakedb.Buildset(id=self.BSID + 1),
fakedb.BuildRequest(id=70, buildsetid=self.BSID + 1, builderid=self.BLDRID1),
fakedb.SourceStamp(id=self.BSID + 1, branch='branch_A'),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID + 1, sourcestampid=self.BSID + 1),
fakedb.Buildset(id=self.BSID + 2),
fakedb.BuildRequest(id=80, buildsetid=self.BSID + 2, builderid=self.BLDRID1),
fakedb.SourceStamp(id=self.BSID + 2, repository='repository_A'),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID + 2, sourcestampid=self.BSID + 2),
fakedb.Buildset(id=self.BSID + 3),
fakedb.BuildRequest(id=90, buildsetid=self.BSID + 3, builderid=self.BLDRID1),
fakedb.SourceStamp(id=self.BSID + 3, branch='branch_A', repository='repository_A'),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID + 3, sourcestampid=self.BSID + 3),
# multiple sourcestamps on the same buildset are possible
fakedb.SourceStamp(id=self.BSID + 4, branch='branch_B', repository='repository_B'),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID + 3, sourcestampid=self.BSID + 4),
])
brlist = yield self.db.buildrequests.getBuildRequests(**kwargs)
self.assertEqual(sorted([br.buildrequestid for br in brlist]), sorted(expected))
def test_getBuildRequests_branch(self):
return self.do_test_getBuildRequests_branch_arg(branch='branch_A', expected=[70, 90])
def test_getBuildRequests_branch_empty(self):
return self.do_test_getBuildRequests_branch_arg(branch='absent_branch', expected=[])
def test_getBuildRequests_repository(self):
return self.do_test_getBuildRequests_branch_arg(
repository='repository_A', expected=[80, 90]
)
def test_getBuildRequests_repository_empty(self):
return self.do_test_getBuildRequests_branch_arg(repository='absent_repository', expected=[])
def test_getBuildRequests_repository_and_branch(self):
return self.do_test_getBuildRequests_branch_arg(
repository='repository_A', branch='branch_A', expected=[90]
)
def test_getBuildRequests_no_repository_nor_branch(self):
return self.do_test_getBuildRequests_branch_arg(expected=[70, 80, 90])
def failWithExpFailure(self, exc, expfailure=None):
if not expfailure:
raise exc
self.flushLoggedErrors(expfailure)
if isinstance(exc, expfailure):
return
raise exc
@defer.inlineCallbacks
def do_test_claimBuildRequests(
self, rows, now, brids, expected=None, expfailure=None, claimed_at=None
):
self.reactor.advance(now)
try:
yield self.insert_test_data(rows)
yield self.db.buildrequests.claimBuildRequests(brids=brids, claimed_at=claimed_at)
results = yield self.db.buildrequests.getBuildRequests()
self.assertNotEqual(expected, None, "unexpected success from claimBuildRequests")
self.assertEqual(
sorted([(r.buildrequestid, r.claimed_at, r.claimed_by_masterid) for r in results]),
sorted(expected),
)
except Exception as e:
self.failWithExpFailure(e, expfailure)
def test_claimBuildRequests_single(self):
return self.do_test_claimBuildRequests(
[
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
],
1300305712,
[44],
[(44, epoch2datetime(1300305712), self.MASTER_ID)],
)
def test_claimBuildRequests_single_explicit_claimed_at(self):
return self.do_test_claimBuildRequests(
[
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
],
1300305712,
[44],
[(44, epoch2datetime(14000000), self.MASTER_ID)],
claimed_at=epoch2datetime(14000000),
)
def test_claimBuildRequests_multiple(self):
return self.do_test_claimBuildRequests(
[
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequest(id=45, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequest(id=46, buildsetid=self.BSID, builderid=self.BLDRID1),
],
1300305712,
[44, 46],
[
(44, epoch2datetime(1300305712), self.MASTER_ID),
(45, None, None),
(46, epoch2datetime(1300305712), self.MASTER_ID),
],
)
def test_claimBuildRequests_stress(self):
return self.do_test_claimBuildRequests(
[
fakedb.BuildRequest(id=id, buildsetid=self.BSID, builderid=self.BLDRID1)
for id in range(1, 1000)
],
1300305713,
list(range(1, 1000)),
[(id, epoch2datetime(1300305713), self.MASTER_ID) for id in range(1, 1000)],
)
def test_claimBuildRequests_other_master_claim(self):
return self.do_test_claimBuildRequests(
[
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequestClaim(
brid=44, masterid=self.OTHER_MASTER_ID, claimed_at=1300103810
),
],
1300305712,
[44],
expfailure=buildrequests.AlreadyClaimedError,
)
@db.skip_for_dialect('mysql')
@defer.inlineCallbacks
def test_claimBuildRequests_other_master_claim_stress(self):
yield self.do_test_claimBuildRequests(
[
fakedb.BuildRequest(id=id, buildsetid=self.BSID, builderid=self.BLDRID1)
for id in range(1, 1000)
]
+ [
fakedb.BuildRequest(id=1000, buildsetid=self.BSID, builderid=self.BLDRID1),
# the fly in the ointment..
fakedb.BuildRequestClaim(
brid=1000, masterid=self.OTHER_MASTER_ID, claimed_at=1300103810
),
],
1300305712,
list(range(1, 1001)),
expfailure=buildrequests.AlreadyClaimedError,
)
results = yield self.db.buildrequests.getBuildRequests(claimed=True)
# check that [1,1000) were not claimed, and 1000 is still claimed
self.assertEqual(
[(r.buildrequestid, r.claimed_by_masterid, r.claimed_at) for r in results][:10],
[(1000, self.OTHER_MASTER_ID, epoch2datetime(1300103810))],
)
@defer.inlineCallbacks
def test_claimBuildRequests_sequential(self):
now = 120350934
self.reactor.advance(now)
yield self.insert_test_data([
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequest(id=45, buildsetid=self.BSID, builderid=self.BLDRID1),
])
yield self.db.buildrequests.claimBuildRequests(brids=[44])
yield self.db.buildrequests.claimBuildRequests(brids=[45])
results = yield self.db.buildrequests.getBuildRequests(claimed=False)
self.assertEqual(results, [])
@defer.inlineCallbacks
def do_test_completeBuildRequests(
self, rows, now, expected=None, expfailure=None, brids=None, complete_at=None
):
if brids is None:
brids = [44]
self.reactor.advance(now)
try:
yield self.insert_test_data(rows)
yield self.db.buildrequests.completeBuildRequests(
brids=brids, results=7, complete_at=complete_at
)
results = yield self.db.buildrequests.getBuildRequests()
self.assertNotEqual(expected, None, "unexpected success from completeBuildRequests")
self.assertEqual(
sorted((r.buildrequestid, r.complete, r.results, r.complete_at) for r in results),
sorted(expected),
)
except Exception as e:
self.failWithExpFailure(e, expfailure)
def test_completeBuildRequests(self):
return self.do_test_completeBuildRequests(
[
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequestClaim(brid=44, masterid=self.MASTER_ID, claimed_at=1300103810),
],
1300305712,
[(44, True, 7, epoch2datetime(1300305712))],
)
def test_completeBuildRequests_explicit_time(self):
return self.do_test_completeBuildRequests(
[
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequestClaim(brid=44, masterid=self.MASTER_ID, claimed_at=1300103810),
],
1300305712,
[(44, True, 7, epoch2datetime(999999))],
complete_at=epoch2datetime(999999),
)
def test_completeBuildRequests_multiple(self):
return self.do_test_completeBuildRequests(
[
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequestClaim(brid=44, masterid=self.MASTER_ID, claimed_at=1300103810),
fakedb.BuildRequest(id=45, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequestClaim(
brid=45, masterid=self.OTHER_MASTER_ID, claimed_at=1300103811
),
fakedb.BuildRequest(id=46, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequestClaim(brid=46, masterid=self.MASTER_ID, claimed_at=1300103812),
],
1300305712,
[
(44, True, 7, epoch2datetime(1300305712)),
(45, False, -1, None),
(46, True, 7, epoch2datetime(1300305712)),
],
brids=[44, 46],
)
def test_completeBuildRequests_stress(self):
return self.do_test_completeBuildRequests(
[
fakedb.BuildRequest(id=id, buildsetid=self.BSID, builderid=self.BLDRID1)
for id in range(1, 280)
]
+ [
fakedb.BuildRequestClaim(brid=id, masterid=self.MASTER_ID, claimed_at=1300103810)
for id in range(1, 280)
],
1300305712,
[(id, True, 7, epoch2datetime(1300305712)) for id in range(1, 280)],
brids=list(range(1, 280)),
)
def test_completeBuildRequests_multiple_notmine(self):
# note that the requests are completed even though they are not mine!
return self.do_test_completeBuildRequests(
[
# two unclaimed requests
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequest(id=45, buildsetid=self.BSID, builderid=self.BLDRID1),
# and one claimed by another master
fakedb.BuildRequest(id=46, buildsetid=self.BSID, builderid=self.BLDRID1),
fakedb.BuildRequestClaim(
brid=46, masterid=self.OTHER_MASTER_ID, claimed_at=1300103812
),
],
1300305712,
[
(44, True, 7, epoch2datetime(1300305712)),
(45, True, 7, epoch2datetime(1300305712)),
(46, True, 7, epoch2datetime(1300305712)),
],
brids=[44, 45, 46],
)
def test_completeBuildRequests_already_completed(self):
return self.do_test_completeBuildRequests(
[
fakedb.BuildRequest(
id=44,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
complete_at=1300104190,
),
],
1300305712,
expfailure=buildrequests.NotClaimedError,
)
def test_completeBuildRequests_no_such(self):
return self.do_test_completeBuildRequests(
[
fakedb.BuildRequest(id=45, buildsetid=self.BSID, builderid=self.BLDRID1),
],
1300305712,
expfailure=buildrequests.NotClaimedError,
)
@defer.inlineCallbacks
def do_test_unclaimMethod(self, method, expected):
yield self.insert_test_data([
# 44: a complete build (should not be unclaimed)
fakedb.BuildRequest(
id=44,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH,
),
fakedb.BuildRequestClaim(
brid=44, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 45: incomplete build belonging to this incarnation
fakedb.BuildRequest(
id=45, buildsetid=self.BSID, builderid=self.BLDRID1, complete=0, complete_at=0
),
fakedb.BuildRequestClaim(
brid=45, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 46: incomplete build belonging to another master
fakedb.BuildRequest(
id=46, buildsetid=self.BSID, builderid=self.BLDRID1, complete=0, complete_at=0
),
fakedb.BuildRequestClaim(
brid=46, masterid=self.OTHER_MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH
),
# 47: unclaimed
fakedb.BuildRequest(
id=47, buildsetid=self.BSID, builderid=self.BLDRID1, complete=0, complete_at=0
),
# 48: claimed by this master, but recently
fakedb.BuildRequest(
id=48, buildsetid=self.BSID, builderid=self.BLDRID1, complete=0, complete_at=0
),
fakedb.BuildRequestClaim(
brid=48, masterid=self.MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH - 50
),
# 49: incomplete old build belonging to another master
fakedb.BuildRequest(
id=49, buildsetid=self.BSID, builderid=self.BLDRID1, complete=0, complete_at=0
),
fakedb.BuildRequestClaim(
brid=49, masterid=self.OTHER_MASTER_ID, claimed_at=self.CLAIMED_AT_EPOCH - 1000
),
])
yield method()
# just select the unclaimed requests
results = yield self.db.buildrequests.getBuildRequests(claimed=False)
self.assertEqual(sorted([r.buildrequestid for r in results]), sorted(expected))
def test_unclaimBuildRequests(self):
to_unclaim = [
44, # completed -> should not be unclaimed
45, # incomplete -> unclaimed
46, # from another master -> not unclaimed
47, # unclaimed -> still unclaimed
48, # claimed -> unclaimed
49, # another master -> not unclaimed
50, # no such buildrequest -> no error
]
return self.do_test_unclaimMethod(
lambda: self.db.buildrequests.unclaimBuildRequests(to_unclaim), [45, 47, 48]
)
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, Tests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'patches',
'changes',
'builders',
'buildsets',
'buildset_properties',
'buildrequests',
'buildset_sourcestamps',
'masters',
'buildrequest_claims',
'sourcestamps',
'sourcestampsets',
'builds',
'workers',
"projects",
]
)
self.db.buildrequests = buildrequests.BuildRequestsConnectorComponent(self.db)
yield self.setUpTests()
def tearDown(self):
return self.tearDownConnectorComponent()
| 28,139 | Python | .py | 632 | 32.484177 | 100 | 0.603761 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,417 | test_logs_compressors.py | buildbot_buildbot/master/buildbot/test/unit/db/test_logs_compressors.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
from typing import TYPE_CHECKING
from twisted.trial import unittest
from buildbot.db import compression
from buildbot.db.logs import RawCompressor
if TYPE_CHECKING:
from typing import ClassVar
from buildbot.db.compression.protocol import CompressorInterface
class TestRawCompressor(unittest.TestCase):
# default no-op compressor
CompressorCls: ClassVar[type[CompressorInterface]] = RawCompressor
def test_dumps_read(self) -> None:
if not self.CompressorCls.available:
raise unittest.SkipTest(f"Compressor '{self.CompressorCls.name}' is unavailable")
data = b'xy' * 10000
compressed_data = self.CompressorCls.dumps(data)
self.assertEqual(data, self.CompressorCls.read(compressed_data))
def test_compressobj_read(self) -> None:
if not self.CompressorCls.available:
raise unittest.SkipTest(f"Compressor '{self.CompressorCls.name}' is unavailable")
input_buffer = [f'xy{idx}'.encode() * 10000 for idx in range(10)]
compress_obj = self.CompressorCls.CompressObj()
def _test():
result_buffer = [compress_obj.compress(e) for e in input_buffer]
result_buffer.append(compress_obj.flush())
self.assertEqual(
b''.join(input_buffer), self.CompressorCls.read(b''.join(result_buffer))
)
_test()
# make sure re-using the same compress obj works
_test()
class TestGZipCompressor(TestRawCompressor):
CompressorCls = compression.GZipCompressor
class TestBZipCompressor(TestRawCompressor):
CompressorCls = compression.BZipCompressor
class TestLZ4Compressor(TestRawCompressor):
CompressorCls = compression.LZ4Compressor
class TestBrotliCompressor(TestRawCompressor):
CompressorCls = compression.BrotliCompressor
class TestZStdCompressor(TestRawCompressor):
CompressorCls = compression.ZStdCompressor
| 2,667 | Python | .py | 55 | 43 | 93 | 0.751644 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,418 | test_build_data.py | buildbot_buildbot/master/buildbot/test/unit/db/test_build_data.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import build_data
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
class Tests(interfaces.InterfaceTests):
common_data = [
fakedb.Worker(id=47, name='linux'),
fakedb.Buildset(id=20),
fakedb.Builder(id=88, name='b1'),
fakedb.Builder(id=89, name='b2'),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=88),
fakedb.BuildRequest(id=42, buildsetid=20, builderid=88),
fakedb.BuildRequest(id=43, buildsetid=20, builderid=89),
fakedb.Master(id=88),
fakedb.Build(id=30, buildrequestid=41, number=7, masterid=88, builderid=88, workerid=47),
fakedb.Build(id=31, buildrequestid=42, number=8, masterid=88, builderid=88, workerid=47),
fakedb.Build(id=40, buildrequestid=43, number=9, masterid=88, builderid=89, workerid=47),
]
def test_signature_add_build_data(self):
@self.assertArgSpecMatches(self.db.build_data.setBuildData)
def setBuildData(self, buildid, name, value, source):
pass
def test_signature_get_build_data(self):
@self.assertArgSpecMatches(self.db.build_data.getBuildData)
def getBuildData(self, buildid, name):
pass
def test_signature_get_build_data_no_value(self):
@self.assertArgSpecMatches(self.db.build_data.getBuildDataNoValue)
def getBuildDataNoValue(self, buildid, name):
pass
def test_signature_get_all_build_data_no_values(self):
@self.assertArgSpecMatches(self.db.build_data.getAllBuildDataNoValues)
def getAllBuildDataNoValues(self, buildid):
pass
@defer.inlineCallbacks
def test_add_data_get_data(self):
yield self.insert_test_data(self.common_data)
yield self.db.build_data.setBuildData(
buildid=30, name='mykey', value=b'myvalue', source='mysource'
)
data_dict = yield self.db.build_data.getBuildData(buildid=30, name='mykey')
self.assertIsInstance(data_dict, build_data.BuildDataModel)
self.assertEqual(
data_dict,
build_data.BuildDataModel(
buildid=30,
name='mykey',
value=b'myvalue',
length=7,
source='mysource',
),
)
@defer.inlineCallbacks
def test_get_data_non_existing(self):
yield self.insert_test_data(self.common_data)
data_dict = yield self.db.build_data.getBuildData(buildid=30, name='mykey')
self.assertIsNone(data_dict)
@defer.inlineCallbacks
def test_add_data_replace_value(self):
yield self.insert_test_data(self.common_data)
yield self.db.build_data.setBuildData(
buildid=30, name='mykey', value=b'myvalue', source='mysource'
)
yield self.db.build_data.setBuildData(
buildid=30, name='mykey', value=b'myvalue2', source='mysource2'
)
data_dict = yield self.db.build_data.getBuildData(buildid=30, name='mykey')
self.assertIsInstance(data_dict, build_data.BuildDataModel)
self.assertEqual(
data_dict,
build_data.BuildDataModel(
buildid=30,
name='mykey',
value=b'myvalue2',
length=8,
source='mysource2',
),
)
@defer.inlineCallbacks
def test_add_data_insert_race(self):
yield self.insert_test_data(self.common_data)
def hook(conn):
value = b'myvalue_old'
insert_values = {
'buildid': 30,
'name': 'mykey',
'value': value,
'length': len(value),
'source': 'mysourec_old',
}
q = self.db.model.build_data.insert().values(insert_values)
conn.execute(q)
self.db.build_data._test_timing_hook = hook
yield self.db.build_data.setBuildData(
buildid=30, name='mykey', value=b'myvalue', source='mysource'
)
data_dict = yield self.db.build_data.getBuildData(buildid=30, name='mykey')
self.assertIsInstance(data_dict, build_data.BuildDataModel)
self.assertEqual(
data_dict,
build_data.BuildDataModel(
buildid=30,
name='mykey',
value=b'myvalue',
length=7,
source='mysource',
),
)
@defer.inlineCallbacks
def test_add_data_get_data_no_value(self):
yield self.insert_test_data(self.common_data)
yield self.db.build_data.setBuildData(
buildid=30, name='mykey', value=b'myvalue', source='mysource'
)
data_dict = yield self.db.build_data.getBuildDataNoValue(buildid=30, name='mykey')
self.assertIsInstance(data_dict, build_data.BuildDataModel)
self.assertEqual(
data_dict,
build_data.BuildDataModel(
buildid=30, name='mykey', value=None, length=7, source='mysource'
),
)
@defer.inlineCallbacks
def test_get_data_no_values_non_existing(self):
yield self.insert_test_data(self.common_data)
data_dict = yield self.db.build_data.getBuildDataNoValue(buildid=30, name='mykey')
self.assertIsNone(data_dict)
@defer.inlineCallbacks
def test_get_all_build_data_no_values(self):
yield self.insert_test_data([
*self.common_data,
fakedb.BuildData(id=91, buildid=30, name='name1', value=b'value1', source='source1'),
fakedb.BuildData(id=92, buildid=30, name='name2', value=b'value2', source='source2'),
fakedb.BuildData(id=93, buildid=31, name='name3', value=b'value3', source='source3'),
])
data_dicts = yield self.db.build_data.getAllBuildDataNoValues(30)
self.assertEqual([d.name for d in data_dicts], ['name1', 'name2'])
for d in data_dicts:
self.assertIsInstance(d, build_data.BuildDataModel)
# note that value is not in dict, but length is
self.assertEqual(
data_dicts[0],
build_data.BuildDataModel(
buildid=30, name='name1', value=None, length=6, source='source1'
),
)
data_dicts = yield self.db.build_data.getAllBuildDataNoValues(31)
self.assertEqual([d.name for d in data_dicts], ['name3'])
data_dicts = yield self.db.build_data.getAllBuildDataNoValues(32)
self.assertEqual([d.name for d in data_dicts], [])
@parameterized.expand([
(1000000, 0, ['name1', 'name2', 'name3', 'name4', 'name5', 'name6']),
(1000001, 0, ['name1', 'name2', 'name3', 'name4', 'name5', 'name6']),
(1000002, 2, ['name1', 'name2', 'name5', 'name6']),
(1000003, 3, ['name1', 'name2', 'name6']),
(1000004, 4, ['name1', 'name2']),
(1000005, 4, ['name1', 'name2']),
])
@defer.inlineCallbacks
def test_remove_old_build_data(
self, older_than_timestamp, exp_num_deleted, exp_remaining_names
):
yield self.insert_test_data([
*self.common_data,
fakedb.Build(
id=50,
buildrequestid=41,
number=17,
masterid=88,
builderid=88,
workerid=47,
complete_at=None,
),
fakedb.Build(
id=51,
buildrequestid=42,
number=18,
masterid=88,
builderid=88,
workerid=47,
complete_at=1000001,
),
fakedb.Build(
id=52,
buildrequestid=43,
number=19,
masterid=88,
builderid=89,
workerid=47,
complete_at=1000002,
),
fakedb.Build(
id=53,
buildrequestid=43,
number=20,
masterid=88,
builderid=89,
workerid=47,
complete_at=1000003,
),
fakedb.BuildData(id=91, buildid=50, name='name1', value=b'value1', source='src1'),
fakedb.BuildData(id=92, buildid=50, name='name2', value=b'value2', source='src2'),
fakedb.BuildData(id=93, buildid=51, name='name3', value=b'value3', source='src3'),
fakedb.BuildData(id=94, buildid=51, name='name4', value=b'value4', source='src4'),
fakedb.BuildData(id=95, buildid=52, name='name5', value=b'value5', source='src5'),
fakedb.BuildData(id=96, buildid=53, name='name6', value=b'value6', source='src6'),
])
num_deleted = yield self.db.build_data.deleteOldBuildData(older_than_timestamp)
self.assertEqual(num_deleted, exp_num_deleted)
remaining_names = []
for buildid in [50, 51, 52, 53]:
data_dicts = yield self.db.build_data.getAllBuildDataNoValues(buildid)
remaining_names.extend(d.name for d in data_dicts)
self.assertEqual(sorted(remaining_names), sorted(exp_remaining_names))
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, Tests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'builds',
'builders',
'masters',
'buildrequests',
'buildsets',
'workers',
'build_data',
"projects",
]
)
self.db.build_data = build_data.BuildDataConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 10,670 | Python | .py | 249 | 32.200803 | 97 | 0.604812 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,419 | test_changesources.py | buildbot_buildbot/master/buildbot/test/unit/db/test_changesources.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
from twisted.internet import defer
from buildbot.db import changesources
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import db
from buildbot.test.util import interfaces
def changeSourceKey(changeSource: changesources.ChangeSourceModel):
return changeSource.id
class Tests(interfaces.InterfaceTests):
# test data
cs42 = fakedb.ChangeSource(id=42, name='cool_source')
cs87 = fakedb.ChangeSource(id=87, name='lame_source')
master13 = fakedb.Master(id=13, name='m1', active=1)
cs42master13 = fakedb.ChangeSourceMaster(changesourceid=42, masterid=13)
master14 = fakedb.Master(id=14, name='m2', active=0)
cs87master14 = fakedb.ChangeSourceMaster(changesourceid=87, masterid=14)
# tests
def test_signature_findChangeSourceId(self):
"""The signature of findChangeSourceId is correct"""
@self.assertArgSpecMatches(self.db.changesources.findChangeSourceId)
def findChangeSourceId(self, name):
pass
@defer.inlineCallbacks
def test_findChangeSourceId_new(self):
"""findChangeSourceId for a new changesource creates it"""
id = yield self.db.changesources.findChangeSourceId('csname')
cs = yield self.db.changesources.getChangeSource(id)
self.assertEqual(cs.name, 'csname')
@defer.inlineCallbacks
def test_findChangeSourceId_existing(self):
"""findChangeSourceId gives the same answer for the same inputs"""
id1 = yield self.db.changesources.findChangeSourceId('csname')
id2 = yield self.db.changesources.findChangeSourceId('csname')
self.assertEqual(id1, id2)
def test_signature_setChangeSourceMaster(self):
"""setChangeSourceMaster has the right signature"""
@self.assertArgSpecMatches(self.db.changesources.setChangeSourceMaster)
def setChangeSourceMaster(self, changesourceid, masterid):
pass
@defer.inlineCallbacks
def test_setChangeSourceMaster_fresh(self):
"""setChangeSourceMaster with a good pair"""
yield self.insert_test_data([self.cs42, self.master13])
yield self.db.changesources.setChangeSourceMaster(42, 13)
cs = yield self.db.changesources.getChangeSource(42)
self.assertEqual(cs.masterid, 13)
@defer.inlineCallbacks
def test_setChangeSourceMaster_inactive_but_linked(self):
"""Inactive changesource but already claimed by an active master"""
d = self.insert_test_data([
self.cs87,
self.master13,
self.master14,
self.cs87master14,
])
d.addCallback(lambda _: self.db.changesources.setChangeSourceMaster(87, 13))
yield self.assertFailure(d, changesources.ChangeSourceAlreadyClaimedError)
@defer.inlineCallbacks
def test_setChangeSourceMaster_active(self):
"""Active changesource already claimed by an active master"""
d = self.insert_test_data([
self.cs42,
self.master13,
self.cs42master13,
])
d.addCallback(lambda _: self.db.changesources.setChangeSourceMaster(42, 14))
yield self.assertFailure(d, changesources.ChangeSourceAlreadyClaimedError)
@defer.inlineCallbacks
def test_setChangeSourceMaster_None(self):
"""A 'None' master disconnects the changesource"""
yield self.insert_test_data([
self.cs87,
self.master14,
self.cs87master14,
])
yield self.db.changesources.setChangeSourceMaster(87, None)
cs = yield self.db.changesources.getChangeSource(87)
self.assertEqual(cs.masterid, None)
@defer.inlineCallbacks
def test_setChangeSourceMaster_None_unowned(self):
"""A 'None' master for a disconnected changesource"""
yield self.insert_test_data([self.cs87])
yield self.db.changesources.setChangeSourceMaster(87, None)
cs = yield self.db.changesources.getChangeSource(87)
self.assertEqual(cs.masterid, None)
def test_signature_getChangeSource(self):
"""getChangeSource has the right signature"""
@self.assertArgSpecMatches(self.db.changesources.getChangeSource)
def getChangeSource(self, changesourceid):
pass
@defer.inlineCallbacks
def test_getChangeSource(self):
"""getChangeSource for a changesource that exists"""
yield self.insert_test_data([self.cs87])
cs = yield self.db.changesources.getChangeSource(87)
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(cs, changesources.ChangeSourceModel(id=87, name='lame_source'))
@defer.inlineCallbacks
def test_getChangeSource_missing(self):
"""getChangeSource for a changesource that doesn't exist"""
cs = yield self.db.changesources.getChangeSource(87)
self.assertEqual(cs, None)
@defer.inlineCallbacks
def test_getChangeSource_active(self):
"""getChangeSource for a changesource that exists and is active"""
yield self.insert_test_data([self.cs42, self.master13, self.cs42master13])
cs = yield self.db.changesources.getChangeSource(42)
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(
cs, changesources.ChangeSourceModel(id=42, name='cool_source', masterid=13)
)
@defer.inlineCallbacks
def test_getChangeSource_inactive_but_linked(self):
"""getChangeSource for a changesource that is assigned but is inactive"""
yield self.insert_test_data([self.cs87, self.master14, self.cs87master14])
cs = yield self.db.changesources.getChangeSource(87)
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(
cs, changesources.ChangeSourceModel(id=87, name='lame_source', masterid=14)
)
# row exists, but marked inactive
def test_signature_getChangeSources(self):
"""getChangeSources has right signature"""
@self.assertArgSpecMatches(self.db.changesources.getChangeSources)
def getChangeSources(self, active=None, masterid=None):
pass
@defer.inlineCallbacks
def test_getChangeSources(self):
"""getChangeSources returns all changesources"""
yield self.insert_test_data([
self.cs42,
self.master13,
self.cs42master13,
self.cs87,
])
cslist = yield self.db.changesources.getChangeSources()
for cs in cslist:
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(
sorted(cslist, key=changeSourceKey),
sorted(
[
changesources.ChangeSourceModel(id=42, name='cool_source', masterid=13),
changesources.ChangeSourceModel(id=87, name='lame_source', masterid=None),
],
key=changeSourceKey,
),
)
@defer.inlineCallbacks
def test_getChangeSources_masterid(self):
"""getChangeSources returns all changesources for a given master"""
yield self.insert_test_data([
self.cs42,
self.master13,
self.cs42master13,
self.cs87,
])
cslist = yield self.db.changesources.getChangeSources(masterid=13)
for cs in cslist:
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(
sorted(cslist, key=changeSourceKey),
sorted(
[
changesources.ChangeSourceModel(id=42, name='cool_source', masterid=13),
],
key=changeSourceKey,
),
)
@defer.inlineCallbacks
def test_getChangeSources_active(self):
"""getChangeSources for (active changesources, all masters)"""
yield self.insert_test_data([self.cs42, self.master13, self.cs42master13, self.cs87])
cslist = yield self.db.changesources.getChangeSources(active=True)
for cs in cslist:
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(
sorted(cslist),
sorted([
changesources.ChangeSourceModel(id=42, name='cool_source', masterid=13),
]),
)
@defer.inlineCallbacks
def test_getChangeSources_active_masterid(self):
"""getChangeSources returns (active changesources, given masters)"""
yield self.insert_test_data([self.cs42, self.master13, self.cs42master13, self.cs87])
cslist = yield self.db.changesources.getChangeSources(active=True, masterid=13)
for cs in cslist:
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(
sorted(cslist),
sorted([
changesources.ChangeSourceModel(id=42, name='cool_source', masterid=13),
]),
)
cslist = yield self.db.changesources.getChangeSources(active=True, masterid=14)
for cs in cslist:
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(sorted(cslist), [])
@defer.inlineCallbacks
def test_getChangeSources_inactive(self):
"""getChangeSources returns (inactive changesources, all masters)"""
yield self.insert_test_data([self.cs42, self.master13, self.cs42master13, self.cs87])
cslist = yield self.db.changesources.getChangeSources(active=False)
for cs in cslist:
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(
sorted(cslist),
sorted([
changesources.ChangeSourceModel(id=87, name='lame_source'),
]),
)
@defer.inlineCallbacks
def test_getChangeSources_inactive_masterid(self):
"""getChangeSources returns (active changesources, given masters)"""
yield self.insert_test_data([self.cs42, self.master13, self.cs42master13, self.cs87])
cslist = yield self.db.changesources.getChangeSources(active=False, masterid=13)
for cs in cslist:
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(sorted(cslist), [])
cslist = yield self.db.changesources.getChangeSources(active=False, masterid=14)
for cs in cslist:
self.assertIsInstance(cs, changesources.ChangeSourceModel)
self.assertEqual(sorted(cslist), []) # always returns [] by spec!
class RealTests(Tests):
# tests that only "real" implementations will pass
pass
class TestRealDB(db.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'changes',
'changesources',
'masters',
'patches',
'sourcestamps',
'changesource_masters',
]
)
self.db.changesources = changesources.ChangeSourcesConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 12,013 | Python | .py | 258 | 37.546512 | 94 | 0.684053 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,420 | test_changes.py | buildbot_buildbot/master/buildbot/test/unit/db/test_changes.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import sqlalchemy as sa
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.data import resultspec
from buildbot.data.changes import FixerMixin
from buildbot.db import builds
from buildbot.db import changes
from buildbot.db import sourcestamps
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
from buildbot.util import epoch2datetime
SOMETIME = 20398573
OTHERTIME = 937239287
class Tests(interfaces.InterfaceTests):
# common sample data
change13_rows = [
fakedb.SourceStamp(id=92, branch="thirteen"),
fakedb.Change(
changeid=13,
author="dustin",
comments="fix spelling",
branch="master",
revision="deadbeef",
committer="justin",
when_timestamp=266738400,
revlink=None,
category=None,
repository='',
codebase='',
project='',
sourcestampid=92,
),
fakedb.ChangeFile(changeid=13, filename='master/README.txt'),
fakedb.ChangeFile(changeid=13, filename='worker/README.txt'),
fakedb.ChangeProperty(
changeid=13, property_name='notest', property_value='["no","Change"]'
),
]
change14_rows = [
fakedb.SourceStamp(id=233, branch="fourteen"),
fakedb.Change(
changeid=14,
author="warner",
comments="fix whitespace",
branch="warnerdb",
revision="0e92a098b",
committer="david",
when_timestamp=266738404,
revlink='http://warner/0e92a098b',
category='devel',
repository='git://warner',
codebase='mainapp',
project='Buildbot',
sourcestampid=233,
),
fakedb.ChangeFile(changeid=14, filename='master/buildbot/__init__.py'),
]
change14_dict = changes.ChangeModel(
changeid=14,
parent_changeids=[],
author='warner',
committer='david',
branch='warnerdb',
category='devel',
comments='fix whitespace',
files=['master/buildbot/__init__.py'],
project='Buildbot',
properties={},
repository='git://warner',
codebase='mainapp',
revision='0e92a098b',
revlink='http://warner/0e92a098b',
when_timestamp=epoch2datetime(266738404),
sourcestampid=233,
)
# tests
def test_signature_addChange(self):
@self.assertArgSpecMatches(self.db.changes.addChange)
def addChange(
self,
author=None,
committer=None,
files=None,
comments=None,
is_dir=None,
revision=None,
when_timestamp=None,
branch=None,
category=None,
revlink='',
properties=None,
repository='',
codebase='',
project='',
uid=None,
):
pass
def test_signature_getChange(self):
@self.assertArgSpecMatches(self.db.changes.getChange)
def getChange(self, key, no_cache=False):
pass
@defer.inlineCallbacks
def test_addChange_getChange(self):
self.reactor.advance(SOMETIME)
changeid = yield self.db.changes.addChange(
author='dustin',
committer='justin',
files=[],
comments='fix spelling',
revision='2d6caa52',
when_timestamp=epoch2datetime(OTHERTIME),
branch='master',
category=None,
revlink=None,
properties={},
repository='repo://',
codebase='cb',
project='proj',
)
chdict = yield self.db.changes.getChange(changeid)
self.assertIsInstance(chdict, changes.ChangeModel)
ss = yield self.db.sourcestamps.getSourceStamp(chdict.sourcestampid)
chdict.sourcestampid = ss
self.assertEqual(
chdict,
changes.ChangeModel(
author='dustin',
committer='justin',
branch='master',
category=None,
changeid=changeid,
parent_changeids=[],
codebase='cb',
comments='fix spelling',
files=[],
project='proj',
properties={},
repository='repo://',
revision='2d6caa52',
revlink=None,
sourcestampid=sourcestamps.SourceStampModel(
branch='master',
codebase='cb',
patch=None,
project='proj',
repository='repo://',
revision='2d6caa52',
created_at=epoch2datetime(SOMETIME),
ssid=ss.ssid,
),
when_timestamp=epoch2datetime(OTHERTIME),
),
)
@defer.inlineCallbacks
def test_addChange_withParent(self):
yield self.insert_test_data(self.change14_rows)
self.reactor.advance(SOMETIME)
changeid = yield self.db.changes.addChange(
author='delanne',
committer='melanne',
files=[],
comments='child of changeid14',
revision='50adad56',
when_timestamp=epoch2datetime(OTHERTIME),
branch='warnerdb',
category='devel',
revlink=None,
properties={},
repository='git://warner',
codebase='mainapp',
project='Buildbot',
)
chdict = yield self.db.changes.getChange(changeid)
self.assertIsInstance(chdict, changes.ChangeModel)
ss = yield self.db.sourcestamps.getSourceStamp(chdict.sourcestampid)
chdict.sourcestampid = ss
self.assertEqual(
chdict,
changes.ChangeModel(
author='delanne',
committer='melanne',
branch='warnerdb',
category='devel',
changeid=changeid,
parent_changeids=[14],
codebase='mainapp',
comments='child of changeid14',
files=[],
project='Buildbot',
properties={},
repository='git://warner',
revision='50adad56',
revlink=None,
sourcestampid=sourcestamps.SourceStampModel(
branch='warnerdb',
codebase='mainapp',
created_at=epoch2datetime(SOMETIME),
patch=None,
project='Buildbot',
repository='git://warner',
revision='50adad56',
ssid=ss.ssid,
),
when_timestamp=epoch2datetime(OTHERTIME),
),
)
@defer.inlineCallbacks
def test_getChange_chdict(self):
yield self.insert_test_data(self.change14_rows)
chdict = yield self.db.changes.getChange(14)
self.assertIsInstance(chdict, changes.ChangeModel)
self.assertEqual(chdict, self.change14_dict)
@defer.inlineCallbacks
def test_getChange_missing(self):
chdict = yield self.db.changes.getChange(14)
self.assertTrue(chdict is None)
def test_signature_getChangeUids(self):
@self.assertArgSpecMatches(self.db.changes.getChangeUids)
def getChangeUids(self, changeid):
pass
@defer.inlineCallbacks
def test_getChangeUids_missing(self):
res = yield self.db.changes.getChangeUids(1)
self.assertEqual(res, [])
@defer.inlineCallbacks
def test_getChangeUids_found(self):
yield self.insert_test_data([
*self.change14_rows,
fakedb.SourceStamp(id=92),
fakedb.User(uid=1),
fakedb.ChangeUser(changeid=14, uid=1),
])
res = yield self.db.changes.getChangeUids(14)
self.assertEqual(res, [1])
@defer.inlineCallbacks
def test_getChangeUids_multi(self):
yield self.insert_test_data(
self.change14_rows
+ self.change13_rows
+ [
fakedb.User(uid=1, identifier="one"),
fakedb.User(uid=2, identifier="two"),
fakedb.User(uid=99, identifier="nooo"),
fakedb.ChangeUser(changeid=14, uid=1),
fakedb.ChangeUser(changeid=14, uid=2),
fakedb.ChangeUser(changeid=13, uid=99), # not selected
]
)
res = yield self.db.changes.getChangeUids(14)
self.assertEqual(sorted(res), [1, 2])
def test_signature_getChanges(self):
@self.assertArgSpecMatches(self.db.changes.getChanges)
def getChanges(self, resultSpec=None):
pass
def insert7Changes(self):
return self.insert_test_data([
fakedb.SourceStamp(id=922),
fakedb.Change(changeid=8, sourcestampid=922),
fakedb.Change(changeid=9, sourcestampid=922),
fakedb.Change(changeid=10, sourcestampid=922),
fakedb.Change(changeid=11, sourcestampid=922),
fakedb.Change(changeid=12, sourcestampid=922),
*self.change13_rows,
*self.change14_rows,
])
@defer.inlineCallbacks
def test_getChanges_subset(self):
yield self.insert7Changes()
rs = resultspec.ResultSpec(order=['-changeid'], limit=5)
rs.fieldMapping = FixerMixin.fieldMapping
changes = yield self.db.changes.getChanges(resultSpec=rs)
changeids = [c.changeid for c in changes]
self.assertEqual(changeids, [10, 11, 12, 13, 14])
@defer.inlineCallbacks
def test_getChangesCount(self):
yield self.insert7Changes()
n = yield self.db.changes.getChangesCount()
self.assertEqual(n, 7)
@defer.inlineCallbacks
def test_getChangesHugeCount(self):
yield self.insert_test_data(
[
fakedb.SourceStamp(id=92),
]
+ [fakedb.Change(changeid=i) for i in range(2, 102)]
)
n = yield self.db.changes.getChangesCount()
self.assertEqual(n, 100)
@defer.inlineCallbacks
def test_getChanges_empty(self):
rs = resultspec.ResultSpec(order=['-changeid'], limit=5)
changes = yield self.db.changes.getChanges(resultSpec=rs)
changeids = [c['changeid'] for c in changes]
self.assertEqual(changeids, [])
yield self.db.changes.getChanges()
changeids = [c['changeid'] for c in changes]
self.assertEqual(changeids, [])
@defer.inlineCallbacks
def test_getChanges_missing(self):
yield self.insert_test_data(self.change13_rows + self.change14_rows)
def check(changes):
# requested all, but only got 2
# sort by changeid, since we assert on change 13 at index 0
changes.sort(key=lambda c: c.changeid)
changeids = [c.changeid for c in changes]
self.assertEqual(changeids, [13, 14])
# double-check that they have .files, etc.
self.assertEqual(
sorted(changes[0].files), sorted(['master/README.txt', 'worker/README.txt'])
)
self.assertEqual(changes[0].properties, {'notest': ('no', 'Change')})
rs = resultspec.ResultSpec(order=['-changeid'], limit=5)
changes = yield self.db.changes.getChanges(resultSpec=rs)
check(changes)
changes = yield self.db.changes.getChanges()
check(changes)
def test_signature_getLatestChangeid(self):
@self.assertArgSpecMatches(self.db.changes.getLatestChangeid)
def getLatestChangeid(self):
pass
@defer.inlineCallbacks
def test_getLatestChangeid(self):
yield self.insert_test_data(self.change13_rows)
changeid = yield self.db.changes.getLatestChangeid()
self.assertEqual(changeid, 13)
@defer.inlineCallbacks
def test_getLatestChangeid_empty(self):
changeid = yield self.db.changes.getLatestChangeid()
self.assertEqual(changeid, None)
def test_signature_getParentChangeIds(self):
@self.assertArgSpecMatches(self.db.changes.getParentChangeIds)
def getParentChangeIds(self, branch, repository, project, codebase):
pass
@defer.inlineCallbacks
def test_getParentChangeIds(self):
yield self.insert_test_data(self.change14_rows + self.change13_rows)
changeid = yield self.db.changes.getParentChangeIds(
branch='warnerdb', repository='git://warner', project='Buildbot', codebase='mainapp'
)
self.assertEqual(changeid, [14])
class RealTests(Tests):
# tests that only "real" implementations will pass
@defer.inlineCallbacks
def test_addChange(self):
self.reactor.advance(SOMETIME)
changeid = yield self.db.changes.addChange(
author='dustin',
committer='justin',
files=['master/LICENSING.txt', 'worker/LICENSING.txt'],
comments='fix spelling',
revision='2d6caa52',
when_timestamp=epoch2datetime(266738400),
branch='master',
category=None,
revlink=None,
properties={'platform': ('linux', 'Change')},
repository='',
codebase='cb',
project='',
)
# check all of the columns of the four relevant tables
def thd_change(conn):
self.assertEqual(changeid, 1)
r = conn.execute(self.db.model.changes.select())
r = r.fetchall()
self.assertEqual(len(r), 1)
self.assertEqual(r[0].changeid, changeid)
self.assertEqual(r[0].author, 'dustin')
self.assertEqual(r[0].committer, 'justin')
self.assertEqual(r[0].comments, 'fix spelling')
self.assertEqual(r[0].branch, 'master')
self.assertEqual(r[0].revision, '2d6caa52')
self.assertEqual(r[0].when_timestamp, 266738400)
self.assertEqual(r[0].category, None)
self.assertEqual(r[0].repository, '')
self.assertEqual(r[0].codebase, 'cb')
self.assertEqual(r[0].project, '')
self.assertEqual(r[0].sourcestampid, 1)
yield self.db.pool.do(thd_change)
def thd_change_files(conn):
query = self.db.model.change_files.select()
query.where(self.db.model.change_files.c.changeid == 1)
query.order_by(self.db.model.change_files.c.filename)
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 2)
self.assertEqual(r[0].filename, 'master/LICENSING.txt')
self.assertEqual(r[1].filename, 'worker/LICENSING.txt')
yield self.db.pool.do(thd_change_files)
def thd_change_properties(conn):
query = self.db.model.change_properties.select()
query.where(self.db.model.change_properties.c.changeid == 1)
query.order_by(self.db.model.change_properties.c.property_name)
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 1)
self.assertEqual(r[0].property_name, 'platform')
self.assertEqual(r[0].property_value, '["linux", "Change"]')
yield self.db.pool.do(thd_change_properties)
def thd_change_users(conn):
query = self.db.model.change_users.select()
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 0)
yield self.db.pool.do(thd_change_users)
def thd_change_sourcestamps(conn):
query = self.db.model.sourcestamps.select()
r = conn.execute(query).mappings()
self.assertEqual(
[dict(row) for row in r.fetchall()],
[
{
'branch': 'master',
'codebase': 'cb',
'id': 1,
'patchid': None,
'project': '',
'repository': '',
'revision': '2d6caa52',
'created_at': SOMETIME,
'ss_hash': 'b777dbd10d1d4c76651335f6a78e278e88b010d6',
}
],
)
yield self.db.pool.do(thd_change_sourcestamps)
@defer.inlineCallbacks
def test_addChange_when_timestamp_None(self):
self.reactor.advance(OTHERTIME)
changeid = yield self.db.changes.addChange(
author='dustin',
committer='justin',
files=[],
comments='fix spelling',
revision='2d6caa52',
when_timestamp=None,
branch='master',
category=None,
revlink=None,
properties={},
repository='',
codebase='',
project='',
)
# check all of the columns of the four relevant tables
def thd(conn):
r = conn.execute(self.db.model.changes.select())
r = r.fetchall()
self.assertEqual(len(r), 1)
self.assertEqual(r[0].changeid, changeid)
self.assertEqual(r[0].when_timestamp, OTHERTIME)
yield self.db.pool.do(thd)
def thd_change(conn):
query = self.db.model.change_files.select()
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 0)
yield self.db.pool.do(thd_change)
def thd_change_file(conn):
query = self.db.model.change_properties.select()
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 0)
yield self.db.pool.do(thd_change_file)
def thd_change_properties(conn):
query = self.db.model.change_users.select()
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 0)
yield self.db.pool.do(thd_change_properties)
@defer.inlineCallbacks
def test_addChange_with_uid(self):
yield self.insert_test_data([
fakedb.User(uid=1, identifier="one"),
])
changeid = yield self.db.changes.addChange(
author='dustin',
committer='justin',
files=[],
comments='fix spelling',
revision='2d6caa52',
when_timestamp=epoch2datetime(OTHERTIME),
branch='master',
category=None,
revlink=None,
properties={},
repository='',
codebase='',
project='',
uid=1,
)
# check all of the columns of the five relevant tables
def thd_change(conn):
r = conn.execute(self.db.model.changes.select())
r = r.fetchall()
self.assertEqual(len(r), 1)
self.assertEqual(r[0].changeid, changeid)
self.assertEqual(r[0].when_timestamp, OTHERTIME)
yield self.db.pool.do(thd_change)
def thd_change_files(conn):
query = self.db.model.change_files.select()
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 0)
yield self.db.pool.do(thd_change_files)
def thd_change_properties(conn):
query = self.db.model.change_properties.select()
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 0)
yield self.db.pool.do(thd_change_properties)
def thd_change_users(conn):
query = self.db.model.change_users.select()
r = conn.execute(query)
r = r.fetchall()
self.assertEqual(len(r), 1)
self.assertEqual(r[0].changeid, 1)
self.assertEqual(r[0].uid, 1)
yield self.db.pool.do(thd_change_users)
@defer.inlineCallbacks
def test_pruneChanges(self):
yield self.insert_test_data([
fakedb.Scheduler(id=29),
fakedb.SourceStamp(id=234, branch="aa"),
fakedb.SourceStamp(id=235, branch="bb"),
fakedb.Change(changeid=11),
fakedb.Change(changeid=12, sourcestampid=234),
fakedb.SchedulerChange(schedulerid=29, changeid=12),
*self.change13_rows,
fakedb.SchedulerChange(schedulerid=29, changeid=13),
*self.change14_rows,
fakedb.SchedulerChange(schedulerid=29, changeid=14),
fakedb.Change(changeid=15, sourcestampid=235),
])
# pruning with a horizon of 2 should delete changes 11, 12 and 13
yield self.db.changes.pruneChanges(2)
def thd(conn):
results = {}
for tbl_name in ('scheduler_changes', 'change_files', 'change_properties', 'changes'):
tbl = self.db.model.metadata.tables[tbl_name]
res = conn.execute(sa.select(tbl.c.changeid))
results[tbl_name] = sorted([row[0] for row in res.fetchall()])
self.assertEqual(
results,
{
'scheduler_changes': [14],
'change_files': [14],
'change_properties': [],
'changes': [14, 15],
},
)
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_pruneChanges_lots(self):
yield self.insert_test_data(
[
fakedb.SourceStamp(id=29),
]
+ [fakedb.Change(changeid=n, sourcestampid=29) for n in range(1, 151)]
)
yield self.db.changes.pruneChanges(1)
def thd(conn):
results = {}
for tbl_name in ('scheduler_changes', 'change_files', 'change_properties', 'changes'):
tbl = self.db.model.metadata.tables[tbl_name]
res = conn.execute(sa.select(sa.func.count()).select_from(tbl))
results[tbl_name] = res.fetchone()[0]
res.close()
self.assertEqual(
results,
{
'scheduler_changes': 0,
'change_files': 0,
'change_properties': 0,
'changes': 1,
},
)
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_pruneChanges_None(self):
yield self.insert_test_data(self.change13_rows)
yield self.db.changes.pruneChanges(None)
def thd(conn):
tbl = self.db.model.changes
res = conn.execute(tbl.select())
self.assertEqual([row.changeid for row in res.fetchall()], [13])
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_getChangesForBuild(self):
rows = [
fakedb.Master(id=88, name="bar"),
fakedb.Worker(id=13, name='one'),
fakedb.Builder(id=77, name='A'),
]
lastID = {
"changeid": 0,
"sourcestampid": 0,
"buildsetid": 0,
"buildsetSourceStampid": 0,
"buildrequestid": 0,
"buildid": 0,
}
codebase_ss = {} # shared state between addChange and addBuild
codebase_prev_change = {}
def addChange(
codebase,
revision,
author,
committer,
comments,
branch='master',
category='cat',
project='proj',
repository='repo',
):
lastID["sourcestampid"] += 1
lastID["changeid"] += 1
parent_changeids = codebase_prev_change.get(codebase)
codebase_prev_change[codebase] = lastID["changeid"]
codebase_ss[codebase] = lastID["changeid"]
changeRows = [
fakedb.SourceStamp(
id=lastID["sourcestampid"], codebase=codebase, revision=revision
),
fakedb.Change(
changeid=lastID["changeid"],
author=author,
committer=committer,
comments=comments,
revision=revision,
sourcestampid=lastID["sourcestampid"],
parent_changeids=parent_changeids,
when_timestamp=SOMETIME + lastID["changeid"],
branch=branch,
category=category,
project=project,
repository=repository,
),
]
return changeRows
def addBuild(codebase_ss, results=0):
lastID["buildid"] += 1
lastID["buildsetid"] += 1
lastID["buildrequestid"] += 1
buildRows = [
fakedb.Buildset(
id=lastID["buildsetid"], reason='foo', submitted_at=1300305012, results=-1
)
]
for ss in codebase_ss.values():
lastID["buildsetSourceStampid"] += 1
buildRows.append(
fakedb.BuildsetSourceStamp(
id=lastID["buildsetSourceStampid"],
sourcestampid=ss,
buildsetid=lastID["buildsetid"],
)
)
codebase_ss.clear()
buildRows.extend([
fakedb.BuildRequest(
id=lastID["buildrequestid"],
buildsetid=lastID["buildsetid"],
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1,
),
fakedb.Build(
id=lastID["buildid"],
buildrequestid=lastID["buildrequestid"],
number=lastID["buildid"],
masterid=88,
builderid=77,
state_string="test",
workerid=13,
started_at=SOMETIME + lastID["buildid"],
complete_at=SOMETIME + 2 * lastID["buildid"],
results=results,
),
])
return buildRows
# Build1 has 1 change per code base
rows.extend(addChange('A', 1, 'franck', 'franck', '1st commit'))
rows.extend(addChange('B', 1, 'alice', 'alice', '2nd commit'))
rows.extend(addChange('C', 1, 'bob', 'bob', '3rd commit'))
rows.extend(addBuild(codebase_ss))
# Build 2 has only one change for codebase A
rows.extend(addChange('A', 2, 'delanne', 'delanne', '4th commit'))
rows.extend(addBuild(codebase_ss))
# Build 3 has only one change for codebase B
rows.extend(addChange('B', 2, 'bob', 'bob', '6th commit'))
rows.extend(addBuild(codebase_ss))
# Build 4 has no change
rows.extend(addBuild(codebase_ss))
# Build 5 has 2 changes for codebase A and 1 change for codebase C
rows.extend(addChange('A', 3, 'franck', 'franck', '7th commit'))
rows.extend(addChange('A', 4, 'alice', 'alice', '8th commit'))
rows.extend(addChange('B', 3, 'bob', 'bob', '9th commit'))
rows.extend(addBuild(codebase_ss))
# Build 6 has only one change for codebase C
rows.extend(addChange('C', 2, 'bob', 'bob', '10th commit'))
rows.extend(addBuild(codebase_ss, 2))
# Build 7 has only one change for codebase C
rows.extend(addChange('C', 3, 'bob', 'bob', '11th commit'))
rows.extend(addBuild(codebase_ss, 2))
# Build 8 has only one change for codebase C, and succeed
rows.extend(addChange('C', 4, 'bob', 'bob', '12th commit'))
rows.extend(addBuild(codebase_ss))
# Build 9 has only one change for codebase C, and fails
rows.extend(addChange('C', 5, 'bob', 'bob', '13th commit'))
rows.extend(addBuild(codebase_ss, 2))
# Build 10 has only one change for codebase C, and fails
rows.extend(addChange('C', 6, 'bob', 'bob', '14th commit'))
rows.extend(addBuild(codebase_ss, 2))
yield self.insert_test_data(rows)
@defer.inlineCallbacks
def expect(buildid, commits):
got = yield self.db.changes.getChangesForBuild(buildid)
got_commits = [c.comments for c in got]
self.assertEqual(sorted(got_commits), sorted(commits))
yield expect(1, ['2nd commit', '3rd commit', '1st commit'])
yield expect(2, ['1st commit', '4th commit'])
yield expect(
3,
[
'2nd commit',
'6th commit',
],
)
yield expect(4, [])
yield expect(
5,
[
'1st commit',
'2nd commit',
'4th commit',
'6th commit',
'7th commit',
'8th commit',
'9th commit',
],
)
yield expect(6, ['3rd commit', '10th commit'])
yield expect(7, ['3rd commit', '10th commit', '11th commit'])
yield expect(8, ['3rd commit', '10th commit', '11th commit', '12th commit'])
yield expect(9, ['13th commit'])
yield expect(10, ['13th commit', '14th commit'])
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'changes',
'change_files',
'change_properties',
'scheduler_changes',
'schedulers',
'sourcestampsets',
'sourcestamps',
'patches',
'change_users',
'users',
'buildsets',
'workers',
'builders',
'masters',
'buildrequests',
'builds',
'buildset_sourcestamps',
'workers',
"projects",
]
)
self.db.changes = changes.ChangesConnectorComponent(self.db)
self.db.builds = builds.BuildsConnectorComponent(self.db)
self.db.sourcestamps = sourcestamps.SourceStampsConnectorComponent(self.db)
self.master = self.db.master
self.master.db = self.db
def tearDown(self):
return self.tearDownConnectorComponent()
| 31,538 | Python | .py | 795 | 27.538365 | 98 | 0.558899 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,421 | test_logs.py | buildbot_buildbot/master/buildbot/test/unit/db/test_logs.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
import base64
import textwrap
from typing import TYPE_CHECKING
import sqlalchemy as sa
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import compression
from buildbot.db import logs
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
from buildbot.util import bytes2unicode
from buildbot.util import unicode2bytes
from buildbot.util.twisted import async_to_deferred
if TYPE_CHECKING:
from typing import Callable
from buildbot.test.util.connector_component import FakeDBConnector
class FakeUnavailableCompressor(compression.CompressorInterface):
name = "fake"
available = False
HEADER = b"[FakeHeader]"
@staticmethod
def dumps(data: bytes) -> bytes:
return FakeUnavailableCompressor.HEADER + data
@staticmethod
def read(data: bytes) -> bytes:
assert data.startswith(FakeUnavailableCompressor.HEADER)
return data[len(FakeUnavailableCompressor.HEADER) :]
class Tests(interfaces.InterfaceTests):
TIMESTAMP_STEP101 = 100000
TIMESTAMP_STEP102 = 200000
backgroundData = [
fakedb.Worker(id=47, name='linux'),
fakedb.Buildset(id=20),
fakedb.Builder(id=88, name='b1'),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=88),
fakedb.Master(id=88),
fakedb.Build(id=30, buildrequestid=41, number=7, masterid=88, builderid=88, workerid=47),
fakedb.Step(id=101, buildid=30, number=1, name='one', started_at=TIMESTAMP_STEP101),
fakedb.Step(id=102, buildid=30, number=2, name='two', started_at=TIMESTAMP_STEP102),
]
insert_test_data: Callable[[list], defer.Deferred]
testLogLines = [
fakedb.Log(
id=201, stepid=101, name='stdio', slug='stdio', complete=0, num_lines=7, type='s'
),
fakedb.LogChunk(
logid=201,
first_line=0,
last_line=1,
compressed=0,
content=textwrap.dedent(
"""\
line zero
line 1"""
+ "x" * 200
),
),
fakedb.LogChunk(
logid=201,
first_line=2,
last_line=4,
compressed=0,
content=textwrap.dedent("""\
line TWO
line 2**2"""),
),
fakedb.LogChunk(logid=201, first_line=5, last_line=5, compressed=0, content="another line"),
fakedb.LogChunk(
logid=201, first_line=6, last_line=6, compressed=0, content="yet another line"
),
]
bug3101Content = base64.b64decode("""
PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0
9PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpbU0tJUFBFRF0Kbm90IGEgd2luMz
IgcGxhdGZvcm0KCmJ1aWxkc2xhdmUudGVzdC51bml0LnRlc3RfcnVucHJvY2Vzcy5UZ
XN0UnVuUHJvY2Vzcy50ZXN0UGlwZVN0cmluZwotLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0
tLS0tLS0tClJhbiAyNjcgdGVzdHMgaW4gNS4zNzhzCgpQQVNTRUQgKHNraXBzPTEsIH
N1Y2Nlc3Nlcz0yNjYpCnByb2dyYW0gZmluaXNoZWQgd2l0aCBleGl0IGNvZGUgMAplb
GFwc2VkVGltZT04LjI0NTcwMg==""")
bug3101Rows = [
fakedb.Log(
id=1470,
stepid=101,
name='problems',
slug='problems',
complete=1,
num_lines=11,
type='t',
),
fakedb.LogChunk(
logid=1470, first_line=0, last_line=10, compressed=0, content=bug3101Content
),
]
@defer.inlineCallbacks
def checkTestLogLines(self):
expLines = [
'line zero',
'line 1' + "x" * 200,
'line TWO',
'',
'line 2**2',
'another line',
'yet another line',
]
for first_line in range(0, 7):
for last_line in range(first_line, 7):
got_lines = yield self.db.logs.getLogLines(201, first_line, last_line)
self.assertEqual(got_lines, "\n".join(expLines[first_line : last_line + 1] + [""]))
# check overflow
self.assertEqual(
(yield self.db.logs.getLogLines(201, 5, 20)), "\n".join(expLines[5:7] + [""])
)
# signature tests
def test_signature_getLog(self):
@self.assertArgSpecMatches(self.db.logs.getLog)
def getLog(self, logid):
pass
def test_signature_getLogBySlug(self):
@self.assertArgSpecMatches(self.db.logs.getLogBySlug)
def getLogBySlug(self, stepid, slug):
pass
def test_signature_getLogs(self):
@self.assertArgSpecMatches(self.db.logs.getLogs)
def getLogs(self, stepid=None):
pass
def test_signature_getLogLines(self):
@self.assertArgSpecMatches(self.db.logs.getLogLines)
def getLogLines(self, logid, first_line, last_line):
pass
def test_signature_addLog(self):
@self.assertArgSpecMatches(self.db.logs.addLog)
def addLog(self, stepid, name, slug, type):
pass
def test_signature_appendLog(self):
@self.assertArgSpecMatches(self.db.logs.appendLog)
def appendLog(self, logid, content):
pass
def test_signature_finishLog(self):
@self.assertArgSpecMatches(self.db.logs.finishLog)
def finishLog(self, logid):
pass
def test_signature_compressLog(self):
@self.assertArgSpecMatches(self.db.logs.compressLog)
def compressLog(self, logid, force=False):
pass
def test_signature_deleteOldLogChunks(self):
@self.assertArgSpecMatches(self.db.logs.deleteOldLogChunks)
def deleteOldLogChunks(self, older_than_timestamp):
pass
# method tests
@defer.inlineCallbacks
def test_getLog(self):
yield self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=201, stepid=101, name="stdio", slug="stdio", complete=0, num_lines=200, type="s"
),
])
logdict = yield self.db.logs.getLog(201)
self.assertIsInstance(logdict, logs.LogModel)
self.assertEqual(
logdict,
logs.LogModel(
id=201,
stepid=101,
name='stdio',
slug='stdio',
complete=False,
num_lines=200,
type='s',
),
)
@defer.inlineCallbacks
def test_getLog_missing(self):
logdict = yield self.db.logs.getLog(201)
self.assertEqual(logdict, None)
@defer.inlineCallbacks
def test_getLogBySlug(self):
yield self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=201, stepid=101, name="stdio", slug="stdio", complete=0, num_lines=200, type="s"
),
fakedb.Log(
id=202,
stepid=101,
name="dbg.log",
slug="dbg_log",
complete=1,
num_lines=200,
type="s",
),
])
logdict = yield self.db.logs.getLogBySlug(101, 'dbg_log')
self.assertIsInstance(logdict, logs.LogModel)
self.assertEqual(logdict.id, 202)
@defer.inlineCallbacks
def test_getLogBySlug_missing(self):
yield self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=201, stepid=101, name="stdio", slug="stdio", complete=0, num_lines=200, type="s"
),
])
logdict = yield self.db.logs.getLogBySlug(102, 'stdio')
self.assertEqual(logdict, None)
@defer.inlineCallbacks
def test_getLogs(self):
yield self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=201, stepid=101, name="stdio", slug="stdio", complete=0, num_lines=200, type="s"
),
fakedb.Log(
id=202,
stepid=101,
name="dbg.log",
slug="dbg_log",
complete=1,
num_lines=300,
type="t",
),
fakedb.Log(
id=203, stepid=102, name="stdio", slug="stdio", complete=0, num_lines=200, type="s"
),
])
logdicts = yield self.db.logs.getLogs(101)
for logdict in logdicts:
self.assertIsInstance(logdict, logs.LogModel)
self.assertEqual(sorted([ld.id for ld in logdicts]), [201, 202])
@defer.inlineCallbacks
def test_getLogLines(self):
yield self.insert_test_data(self.backgroundData + self.testLogLines)
yield self.checkTestLogLines()
# check line number reversal
self.assertEqual((yield self.db.logs.getLogLines(201, 6, 3)), '')
@defer.inlineCallbacks
def test_getLogLines_empty(self):
yield self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=201, stepid=101, name="stdio", slug="stdio", complete=0, num_lines=200, type="s"
),
])
self.assertEqual((yield self.db.logs.getLogLines(201, 9, 99)), '')
self.assertEqual((yield self.db.logs.getLogLines(999, 9, 99)), '')
@defer.inlineCallbacks
def test_getLogLines_bug3101(self):
# regression test for #3101
content = self.bug3101Content
yield self.insert_test_data(self.backgroundData + self.bug3101Rows)
# overall content is the same, with '\n' padding at the end
expected = bytes2unicode(self.bug3101Content + b'\n')
self.assertEqual((yield self.db.logs.getLogLines(1470, 0, 99)), expected)
# try to fetch just one line
expected = bytes2unicode(content.split(b'\n')[0] + b'\n')
self.assertEqual((yield self.db.logs.getLogLines(1470, 0, 0)), expected)
@defer.inlineCallbacks
def test_addLog_getLog(self):
yield self.insert_test_data(self.backgroundData)
logid = yield self.db.logs.addLog(
stepid=101, name='config.log', slug='config_log', type='t'
)
logdict = yield self.db.logs.getLog(logid)
self.assertIsInstance(logdict, logs.LogModel)
self.assertEqual(
logdict,
logs.LogModel(
id=logid,
stepid=101,
name='config.log',
slug='config_log',
complete=False,
num_lines=0,
type='t',
),
)
@defer.inlineCallbacks
def test_appendLog_getLogLines(self):
yield self.insert_test_data(self.backgroundData + self.testLogLines)
logid = yield self.db.logs.addLog(stepid=102, name='another', slug='another', type='s')
self.assertEqual((yield self.db.logs.appendLog(logid, 'xyz\n')), (0, 0))
self.assertEqual((yield self.db.logs.appendLog(201, 'abc\ndef\n')), (7, 8))
self.assertEqual((yield self.db.logs.appendLog(logid, 'XYZ\n')), (1, 1))
self.assertEqual((yield self.db.logs.getLogLines(201, 6, 7)), "yet another line\nabc\n")
self.assertEqual((yield self.db.logs.getLogLines(201, 7, 8)), "abc\ndef\n")
self.assertEqual((yield self.db.logs.getLogLines(201, 8, 8)), "def\n")
self.assertEqual((yield self.db.logs.getLogLines(logid, 0, 1)), "xyz\nXYZ\n")
self.assertEqual(
(yield self.db.logs.getLog(logid)),
logs.LogModel(
complete=False,
id=logid,
name='another',
slug='another',
num_lines=2,
stepid=102,
type='s',
),
)
@defer.inlineCallbacks
def test_compressLog(self):
yield self.insert_test_data(self.backgroundData + self.testLogLines)
yield self.db.logs.compressLog(201)
# test log lines should still be readable just the same
yield self.checkTestLogLines()
@defer.inlineCallbacks
def test_addLogLines_big_chunk(self):
yield self.insert_test_data(self.backgroundData + self.testLogLines)
self.assertEqual(
(yield self.db.logs.appendLog(201, 'abc\n' * 20000)), # 80k
(7, 20006),
)
lines = yield self.db.logs.getLogLines(201, 7, 50000)
self.assertEqual(len(lines), 80000)
self.assertEqual(lines, ('abc\n' * 20000))
@defer.inlineCallbacks
def test_addLogLines_big_chunk_big_lines(self):
yield self.insert_test_data(self.backgroundData + self.testLogLines)
line = 'x' * 33000 + '\n'
self.assertEqual(
(yield self.db.logs.appendLog(201, line * 3)), (7, 9)
) # three long lines, all truncated
lines = yield self.db.logs.getLogLines(201, 7, 100)
self.assertEqual(len(lines), 99003)
self.assertEqual(lines, (line * 3))
class RealTests(Tests):
insert_test_data: Callable[[list], defer.Deferred]
db: FakeDBConnector
@defer.inlineCallbacks
def test_addLogLines_db(self):
yield self.insert_test_data(self.backgroundData + self.testLogLines)
self.assertEqual((yield self.db.logs.appendLog(201, 'abc\ndef\nghi\njkl\n')), (7, 10))
def thd(conn):
res = conn.execute(
self.db.model.logchunks.select().where(self.db.model.logchunks.c.first_line > 6)
).mappings()
row = res.fetchone()
res.close()
return dict(row)
newRow = yield self.db.pool.do(thd)
self.assertEqual(
newRow,
{
'logid': 201,
'first_line': 7,
'last_line': 10,
'content': b'abc\ndef\nghi\njkl',
'compressed': 0,
},
)
@defer.inlineCallbacks
def test_addLogLines_huge_lines(self):
yield self.insert_test_data(self.backgroundData + self.testLogLines)
line = 'xy' * 70000 + '\n'
yield self.db.logs.appendLog(201, line * 3)
for lineno in 7, 8, 9:
line = yield self.db.logs.getLogLines(201, lineno, lineno)
self.assertEqual(len(line), 65537)
def test_splitBigChunk_unicode_misalignment(self):
unaligned = ('a ' + '\N{SNOWMAN}' * 30000 + '\n').encode('utf-8')
# the first 65536 bytes of that line are not valid utf-8
with self.assertRaises(UnicodeDecodeError):
unaligned[:65536].decode('utf-8')
chunk, _ = self.db.logs._splitBigChunk(unaligned, 1)
# see that it was truncated by two bytes, and now properly decodes
self.assertEqual(len(chunk), 65534)
chunk.decode('utf-8')
@defer.inlineCallbacks
def test_no_compress_small_chunk(self):
yield self.insert_test_data(self.backgroundData + self.testLogLines)
self.db.master.config.logCompressionMethod = "gz"
self.assertEqual((yield self.db.logs.appendLog(201, 'abc\n')), (7, 7))
def thd(conn):
res = conn.execute(
self.db.model.logchunks.select().where(self.db.model.logchunks.c.first_line > 6)
).mappings()
row = res.fetchone()
res.close()
return dict(row)
newRow = yield self.db.pool.do(thd)
self.assertEqual(
newRow,
{'logid': 201, 'first_line': 7, 'last_line': 7, 'content': b'abc', 'compressed': 0},
)
async def _test_compress_big_chunk(
self,
dumps: Callable[[bytes], bytes],
compressed_id: int,
) -> None:
await self.insert_test_data(self.backgroundData + self.testLogLines)
line = 'xy' * 10000
self.assertEqual((await self.db.logs.appendLog(201, line + '\n')), (7, 7))
def thd(conn):
res = conn.execute(
self.db.model.logchunks.select().where(self.db.model.logchunks.c.first_line > 6)
).mappings()
row = res.fetchone()
res.close()
return dict(row)
newRow = await self.db.pool.do(thd)
self.assertEqual(
newRow,
{
'logid': 201,
'first_line': 7,
'last_line': 7,
'content': dumps(unicode2bytes(line)),
'compressed': compressed_id,
},
)
@async_to_deferred
async def test_raw_compress_big_chunk(self):
self.db.master.config.logCompressionMethod = "raw"
await self._test_compress_big_chunk(lambda d: d, 0)
@async_to_deferred
async def test_gz_compress_big_chunk(self):
self.db.master.config.logCompressionMethod = "gz"
await self._test_compress_big_chunk(compression.GZipCompressor.dumps, 1)
@async_to_deferred
async def test_bz2_compress_big_chunk(self):
self.db.master.config.logCompressionMethod = "bz2"
await self._test_compress_big_chunk(compression.BZipCompressor.dumps, 2)
@async_to_deferred
async def test_lz4_compress_big_chunk(self):
try:
import lz4 # noqa: F401
except ImportError as e:
raise unittest.SkipTest("lz4 not installed, skip the test") from e
self.db.master.config.logCompressionMethod = "lz4"
await self._test_compress_big_chunk(compression.LZ4Compressor.dumps, 3)
@async_to_deferred
async def test_zstd_compress_big_chunk(self):
try:
import zstandard # noqa: F401
except ImportError as e:
raise unittest.SkipTest("zstandard not installed, skip the test") from e
self.db.master.config.logCompressionMethod = "zstd"
await self._test_compress_big_chunk(compression.ZStdCompressor.dumps, 4)
@async_to_deferred
async def test_br_compress_big_chunk(self):
try:
import brotli # noqa: F401
except ImportError as e:
raise unittest.SkipTest("brotli not installed, skip the test") from e
self.db.master.config.logCompressionMethod = "br"
await self._test_compress_big_chunk(compression.BrotliCompressor.dumps, 5)
@defer.inlineCallbacks
def do_addLogLines_huge_log(self, NUM_CHUNKS=3000, chunk=('xy' * 70 + '\n') * 3):
if chunk.endswith("\n"):
chunk = chunk[:-1]
linesperchunk = chunk.count("\n") + 1
test_data = [
fakedb.LogChunk(
logid=201,
first_line=i * linesperchunk,
last_line=i * linesperchunk + linesperchunk - 1,
compressed=0,
content=chunk,
)
for i in range(NUM_CHUNKS)
]
yield self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=201,
stepid=101,
name="stdio",
slug="stdio",
complete=0,
num_lines=NUM_CHUNKS * 3,
type="s",
),
*test_data,
])
wholeLog = yield self.db.logs.getLogLines(201, 0, NUM_CHUNKS * 3)
for i in range(10):
yield self.db.logs.compressLog(201)
wholeLog2 = yield self.db.logs.getLogLines(201, 0, NUM_CHUNKS * 3)
self.assertEqual(wholeLog, wholeLog2)
self.assertEqual(wholeLog, wholeLog2)
def countChunk(conn):
tbl = self.db.model.logchunks
q = sa.select(sa.func.count(tbl.c.content))
q = q.where(tbl.c.logid == 201)
return conn.execute(q).fetchone()[0]
chunks = yield self.db.pool.do(countChunk)
# make sure MAX_CHUNK_LINES is taken in account
self.assertGreaterEqual(
chunks, NUM_CHUNKS * linesperchunk / logs.LogsConnectorComponent.MAX_CHUNK_LINES
)
def test_addLogLines_huge_log(self):
return self.do_addLogLines_huge_log()
def test_addLogLines_huge_log_lots_line(self):
return self.do_addLogLines_huge_log(NUM_CHUNKS=3000, chunk='x\n' * 50)
def test_addLogLines_huge_log_lots_snowmans(self):
return self.do_addLogLines_huge_log(NUM_CHUNKS=3000, chunk='\N{SNOWMAN}\n' * 50)
@defer.inlineCallbacks
def test_compressLog_non_existing_log(self):
yield self.db.logs.compressLog(201)
logdict = yield self.db.logs.getLog(201)
self.assertEqual(logdict, None)
@defer.inlineCallbacks
def test_compressLog_empty_log(self):
yield self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=201, stepid=101, name="stdio", slug="stdio", complete=1, num_lines=0, type="s"
),
])
yield self.db.logs.compressLog(201)
logdict = yield self.db.logs.getLog(201)
self.assertEqual(
logdict,
logs.LogModel(
stepid=101,
num_lines=0,
name='stdio',
id=201,
type='s',
slug='stdio',
complete=True,
),
)
@defer.inlineCallbacks
def test_deleteOldLogChunks_basic(self):
yield self.insert_test_data(self.backgroundData)
logids = []
for stepid in (101, 102):
for i in range(stepid):
logid = yield self.db.logs.addLog(
stepid=stepid, name='another' + str(i), slug='another' + str(i), type='s'
)
yield self.db.logs.appendLog(logid, 'xyz\n')
logids.append(logid)
deleted_chunks = yield self.db.logs.deleteOldLogChunks(
(self.TIMESTAMP_STEP102 + self.TIMESTAMP_STEP101) / 2
)
self.assertEqual(deleted_chunks, 101)
deleted_chunks = yield self.db.logs.deleteOldLogChunks(
self.TIMESTAMP_STEP102 + self.TIMESTAMP_STEP101
)
self.assertEqual(deleted_chunks, 102)
deleted_chunks = yield self.db.logs.deleteOldLogChunks(
self.TIMESTAMP_STEP102 + self.TIMESTAMP_STEP101
)
self.assertEqual(deleted_chunks, 0)
deleted_chunks = yield self.db.logs.deleteOldLogChunks(0)
self.assertEqual(deleted_chunks, 0)
for logid in logids:
logdict = yield self.db.logs.getLog(logid)
self.assertEqual(logdict.type, 'd')
# we make sure we can still getLogLines, it will just return empty value
lines = yield self.db.logs.getLogLines(logid, 0, logdict.num_lines)
self.assertEqual(lines, '')
@async_to_deferred
async def test_insert_logs_non_existing_compression_method(self):
LOG_ID = 201
await self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=LOG_ID, stepid=101, name="stdio", slug="stdio", complete=0, num_lines=1, type="s"
),
fakedb.LogChunk(
logid=LOG_ID, first_line=0, last_line=0, compressed=0, content=b"fake_log_chunk\n"
),
])
def _thd_get_log_chunks(conn):
res = conn.execute(
self.db.model.logchunks.select().where(self.db.model.logchunks.c.logid == LOG_ID)
).mappings()
return [dict(row) for row in res]
self.db.master.config.logCompressionMethod = "non_existing"
await self.db.logs.compressLog(LOG_ID)
self.assertEqual(
await self.db.pool.do(_thd_get_log_chunks),
[
{
'compressed': 0,
'content': b'fake_log_chunk\n',
'first_line': 0,
'last_line': 0,
'logid': LOG_ID,
}
],
)
await self.db.logs.appendLog(LOG_ID, 'other_chunk\n')
self.assertEqual(
await self.db.pool.do(_thd_get_log_chunks),
[
{
'compressed': 0,
'content': b'fake_log_chunk\n',
'first_line': 0,
'last_line': 0,
'logid': LOG_ID,
},
{
'compressed': 0,
'content': b'other_chunk',
'first_line': 1,
'last_line': 1,
'logid': LOG_ID,
},
],
)
@async_to_deferred
async def test_get_logs_non_existing_compression_method(self):
LOG_ID = 201
# register fake compressor
FAKE_COMPRESSOR_ID = max(self.db.logs.COMPRESSION_BYID.keys()) + 1
self.db.logs.COMPRESSION_BYID[FAKE_COMPRESSOR_ID] = FakeUnavailableCompressor
NON_EXISTING_COMPRESSOR_ID = max(self.db.logs.COMPRESSION_BYID.keys()) + 1
await self.insert_test_data([
*self.backgroundData,
fakedb.Log(
id=LOG_ID, stepid=101, name="stdio", slug="stdio", complete=0, num_lines=1, type="s"
),
fakedb.LogChunk(
logid=LOG_ID,
first_line=0,
last_line=0,
compressed=FAKE_COMPRESSOR_ID,
content=b"fake_log_chunk\n",
),
fakedb.LogChunk(
logid=LOG_ID,
first_line=1,
last_line=1,
compressed=NON_EXISTING_COMPRESSOR_ID,
content=b"fake_log_chunk\n",
),
])
with self.assertRaises(logs.LogCompressionFormatUnavailableError):
await self.db.logs.getLogLines(logid=LOG_ID, first_line=0, last_line=0)
with self.assertRaises(logs.LogCompressionFormatUnavailableError):
await self.db.logs.getLogLines(logid=LOG_ID, first_line=1, last_line=1)
self.flushLoggedErrors(logs.LogCompressionFormatUnavailableError)
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'logs',
'logchunks',
'steps',
'builds',
'builders',
'masters',
'buildrequests',
'buildsets',
'workers',
"projects",
]
)
self.db.logs = logs.LogsConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 27,339 | Python | .py | 675 | 29.715556 | 100 | 0.590201 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,422 | test_model.py | buildbot_buildbot/master/buildbot/test/unit/db/test_model.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import os
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import model
from buildbot.test.util import db
class DBConnector_Basic(db.RealDatabaseMixin, unittest.TestCase):
"""
Basic tests of the DBConnector class - all start with an empty DB
"""
@defer.inlineCallbacks
def setUp(self):
yield self.setUpRealDatabase(
basedir=os.path.abspath('basedir'),
want_pool=False,
)
# mock out the pool, and set up the model
self.db = mock.Mock()
self.db.pool.do = lambda thd: defer.maybeDeferred(thd, self.db_engine.connect())
self.db.pool.do_with_engine = lambda thd: defer.maybeDeferred(thd, self.db_engine)
self.db.model = model.Model(self.db)
self.db.start()
def tearDown(self):
self.db.stop()
return self.tearDownRealDatabase()
@defer.inlineCallbacks
def test_is_current_empty(self):
res = yield self.db.model.is_current()
self.assertFalse(res)
@defer.inlineCallbacks
def test_is_current_full(self):
yield self.db.model.upgrade()
res = yield self.db.model.is_current()
self.assertTrue(res)
# the upgrade method is very well-tested by the integration tests; the
# remainder of the object is just tables.
| 2,069 | Python | .py | 50 | 36.32 | 90 | 0.720618 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,423 | test_sourcestamps.py | buildbot_buildbot/master/buildbot/test/unit/db/test_sourcestamps.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
from typing import TYPE_CHECKING
from typing import Callable
from typing import Generator
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db import sourcestamps
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import interfaces
from buildbot.util import epoch2datetime
if TYPE_CHECKING:
from buildbot.test.util.connector_component import FakeDBConnector
CREATED_AT = 927845299
def sourceStampKey(sourceStamp: sourcestamps.SourceStampModel):
return (sourceStamp.repository, sourceStamp.branch, sourceStamp.created_at)
class Tests(interfaces.InterfaceTests):
insert_test_data: Callable[[list], defer.Deferred]
db: FakeDBConnector
def test_signature_findSourceStampId(self):
@self.assertArgSpecMatches(self.db.sourcestamps.findSourceStampId)
def findSourceStampId(
self,
branch=None,
revision=None,
repository=None,
project=None,
codebase=None,
patch_body=None,
patch_level=None,
patch_author=None,
patch_comment=None,
patch_subdir=None,
):
pass
def test_signature_getSourceStamp(self):
@self.assertArgSpecMatches(self.db.sourcestamps.getSourceStamp)
def getSourceStamp(self, key, no_cache=False):
pass
def test_signature_getSourceStamps(self):
@self.assertArgSpecMatches(self.db.sourcestamps.getSourceStamps)
def getSourceStamps(self):
pass
def test_signature_getSourceStampsForBuild(self):
@self.assertArgSpecMatches(self.db.sourcestamps.getSourceStampsForBuild)
def getSourceStampsForBuild(self, buildid):
pass
def test_signature_get_sourcestamps_for_buildset(self):
@self.assertArgSpecMatches(self.db.sourcestamps.get_sourcestamps_for_buildset)
def get_sourcestamps_for_buildset(self, buildsetid):
pass
@defer.inlineCallbacks
def test_findSourceStampId_simple(self):
self.reactor.advance(CREATED_AT)
ssid = yield self.db.sourcestamps.findSourceStampId(
branch='production',
revision='abdef',
repository='test://repo',
codebase='cb',
project='stamper',
)
ssdict = yield self.db.sourcestamps.getSourceStamp(ssid)
self.assertEqual(
ssdict,
sourcestamps.SourceStampModel(
branch='production',
codebase='cb',
patch=None,
project='stamper',
repository='test://repo',
revision='abdef',
ssid=ssid,
created_at=epoch2datetime(CREATED_AT),
),
)
@defer.inlineCallbacks
def test_findSourceStampId_simple_unique(self):
ssid1 = yield self.db.sourcestamps.findSourceStampId(
branch='production',
revision='abdef',
repository='test://repo',
codebase='cb',
project='stamper',
)
ssid2 = yield self.db.sourcestamps.findSourceStampId(
branch='production',
revision='xxxxx', # different revision
repository='test://repo',
codebase='cb',
project='stamper',
)
ssid3 = yield self.db.sourcestamps.findSourceStampId( # same as ssid1
branch='production',
revision='abdef',
repository='test://repo',
codebase='cb',
project='stamper',
)
self.assertEqual(ssid1, ssid3)
self.assertNotEqual(ssid1, ssid2)
@defer.inlineCallbacks
def test_findSourceStampId_simple_unique_patch(self):
ssid1 = yield self.db.sourcestamps.findSourceStampId(
branch='production',
revision='abdef',
repository='test://repo',
codebase='cb',
project='stamper',
patch_body=b'++ --',
patch_level=1,
patch_author='me',
patch_comment='hi',
patch_subdir='.',
)
ssid2 = yield self.db.sourcestamps.findSourceStampId(
branch='production',
revision='abdef',
repository='test://repo',
codebase='cb',
project='stamper',
patch_body=b'++ --',
patch_level=1,
patch_author='me',
patch_comment='hi',
patch_subdir='.',
)
# even with the same patch contents, we get different ids
self.assertNotEqual(ssid1, ssid2)
@defer.inlineCallbacks
def test_findSourceStampId_patch(self):
self.reactor.advance(CREATED_AT)
ssid = yield self.db.sourcestamps.findSourceStampId(
branch='production',
revision='abdef',
repository='test://repo',
codebase='cb',
project='stamper',
patch_body=b'my patch',
patch_level=3,
patch_subdir='master/',
patch_author='me',
patch_comment="comment",
)
ssdict = yield self.db.sourcestamps.getSourceStamp(ssid)
self.assertEqual(
ssdict,
sourcestamps.SourceStampModel(
branch='production',
codebase='cb',
project='stamper',
repository='test://repo',
revision='abdef',
created_at=epoch2datetime(CREATED_AT),
ssid=ssid,
patch=sourcestamps.PatchModel(
patchid=1,
author='me',
body=b'my patch',
comment='comment',
level=3,
subdir='master/',
),
),
)
@defer.inlineCallbacks
def test_getSourceStamp_simple(self):
yield self.insert_test_data([
fakedb.SourceStamp(
id=234,
branch='br',
revision='rv',
repository='rep',
codebase='cb',
project='prj',
created_at=CREATED_AT,
),
])
ssdict = yield self.db.sourcestamps.getSourceStamp(234)
self.assertEqual(
ssdict,
sourcestamps.SourceStampModel(
ssid=234,
created_at=epoch2datetime(CREATED_AT),
branch='br',
revision='rv',
repository='rep',
codebase='cb',
project='prj',
patch=None,
),
)
@defer.inlineCallbacks
def test_getSourceStamp_simple_None(self):
"check that NULL branch and revision are handled correctly"
yield self.insert_test_data([
fakedb.SourceStamp(
id=234, branch=None, revision=None, repository='rep', codebase='cb', project='prj'
),
])
ssdict = yield self.db.sourcestamps.getSourceStamp(234)
self.assertIsInstance(ssdict, sourcestamps.SourceStampModel)
self.assertEqual((ssdict.branch, ssdict.revision), (None, None))
@defer.inlineCallbacks
def test_getSourceStamp_patch(self) -> Generator[defer.Deferred, None, None]:
yield self.insert_test_data([
fakedb.Patch(
id=99,
patch_base64='aGVsbG8sIHdvcmxk',
patch_author='bar',
patch_comment='foo',
subdir='/foo',
patchlevel=3,
),
fakedb.SourceStamp(id=234, patchid=99),
])
res = yield self.db.sourcestamps.getSourceStamp(234)
assert res is not None
ssdict = res
self.assertIsInstance(ssdict, sourcestamps.SourceStampModel)
self.assertIsInstance(ssdict.patch, sourcestamps.PatchModel)
self.assertEqual(ssdict.patch.body, b'hello, world')
self.assertEqual(ssdict.patch.level, 3)
self.assertEqual(ssdict.patch.author, 'bar')
self.assertEqual(ssdict.patch.comment, 'foo')
self.assertEqual(ssdict.patch.subdir, '/foo')
@defer.inlineCallbacks
def test_getSourceStamp_nosuch(self):
ssdict = yield self.db.sourcestamps.getSourceStamp(234)
self.assertEqual(ssdict, None)
@defer.inlineCallbacks
def test_getSourceStamps(self):
yield self.insert_test_data([
fakedb.Patch(
id=99,
patch_base64='aGVsbG8sIHdvcmxk',
patch_author='bar',
patch_comment='foo',
subdir='/foo',
patchlevel=3,
),
fakedb.SourceStamp(
id=234,
revision='r',
project='p',
codebase='c',
repository='rep',
branch='b',
patchid=99,
created_at=CREATED_AT,
),
fakedb.SourceStamp(
id=235,
revision='r2',
project='p2',
codebase='c2',
repository='rep2',
branch='b2',
patchid=None,
created_at=CREATED_AT + 10,
),
])
db_sourcestamps = yield self.db.sourcestamps.getSourceStamps()
self.assertEqual(
sorted(db_sourcestamps, key=sourceStampKey),
sorted(
[
sourcestamps.SourceStampModel(
branch='b',
codebase='c',
project='p',
repository='rep',
revision='r',
created_at=epoch2datetime(CREATED_AT),
ssid=234,
patch=sourcestamps.PatchModel(
patchid=99,
author='bar',
body=b'hello, world',
comment='foo',
level=3,
subdir='/foo',
),
),
sourcestamps.SourceStampModel(
branch='b2',
codebase='c2',
project='p2',
repository='rep2',
revision='r2',
created_at=epoch2datetime(CREATED_AT + 10),
ssid=235,
patch=None,
),
],
key=sourceStampKey,
),
)
@defer.inlineCallbacks
def test_getSourceStamps_empty(self):
sourcestamps = yield self.db.sourcestamps.getSourceStamps()
self.assertEqual(sourcestamps, [])
@defer.inlineCallbacks
def test_get_sourcestamps_for_buildset_one_codebase(self):
yield self.insert_test_data([
fakedb.Master(id=88, name="bar"),
fakedb.Worker(id=13, name="one"),
fakedb.Builder(id=77, name="A"),
fakedb.SourceStamp(id=234, codebase="A", created_at=CREATED_AT, revision="aaa"),
fakedb.Buildset(id=30, reason="foo", submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
])
db_sourcestamps = yield self.db.sourcestamps.get_sourcestamps_for_buildset(30)
expected = [
sourcestamps.SourceStampModel(
branch="master",
codebase="A",
created_at=epoch2datetime(CREATED_AT),
patch=None,
project="proj",
repository="repo",
revision="aaa",
ssid=234,
)
]
self.assertEqual(
sorted(db_sourcestamps, key=sourceStampKey), sorted(expected, key=sourceStampKey)
)
@defer.inlineCallbacks
def test_get_sourcestamps_for_buildset_three_codebases(self):
yield self.insert_test_data([
fakedb.Master(id=88, name="bar"),
fakedb.Worker(id=13, name="one"),
fakedb.Builder(id=77, name="A"),
fakedb.SourceStamp(id=234, codebase="A", created_at=CREATED_AT, revision="aaa"),
fakedb.SourceStamp(id=235, codebase="B", created_at=CREATED_AT + 10, revision="bbb"),
fakedb.SourceStamp(id=236, codebase="C", created_at=CREATED_AT + 20, revision="ccc"),
fakedb.Buildset(id=30, reason="foo", submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.BuildsetSourceStamp(sourcestampid=235, buildsetid=30),
fakedb.BuildsetSourceStamp(sourcestampid=236, buildsetid=30),
])
db_sourcestamps = yield self.db.sourcestamps.get_sourcestamps_for_buildset(30)
expected = [
sourcestamps.SourceStampModel(
branch="master",
codebase="A",
created_at=epoch2datetime(CREATED_AT),
patch=None,
project="proj",
repository="repo",
revision="aaa",
ssid=234,
),
sourcestamps.SourceStampModel(
branch="master",
codebase="B",
created_at=epoch2datetime(CREATED_AT + 10),
patch=None,
project="proj",
repository="repo",
revision="bbb",
ssid=235,
),
sourcestamps.SourceStampModel(
branch="master",
codebase="C",
created_at=epoch2datetime(CREATED_AT + 20),
patch=None,
project="proj",
repository="repo",
revision="ccc",
ssid=236,
),
]
self.assertEqual(
sorted(db_sourcestamps, key=sourceStampKey), sorted(expected, key=sourceStampKey)
)
@defer.inlineCallbacks
def do_test_getSourceStampsForBuild(self, rows, buildid, expected):
yield self.insert_test_data(rows)
sourcestamps = yield self.db.sourcestamps.getSourceStampsForBuild(buildid)
self.assertEqual(
sorted(sourcestamps, key=sourceStampKey), sorted(expected, key=sourceStampKey)
)
def test_getSourceStampsForBuild_OneCodeBase(self):
rows = [
fakedb.Master(id=88, name="bar"),
fakedb.Worker(id=13, name='one'),
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, codebase='A', created_at=CREATED_AT, revision="aaa"),
# fakedb.Change(changeid=14, codebase='A', sourcestampid=234),
fakedb.Buildset(id=30, reason='foo', submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.BuildRequest(
id=19, buildsetid=30, builderid=77, priority=13, submitted_at=1300305712, results=-1
),
fakedb.Build(
id=50,
buildrequestid=19,
number=5,
masterid=88,
builderid=77,
state_string="test",
workerid=13,
started_at=1304262222,
),
]
expected = [
sourcestamps.SourceStampModel(
branch='master',
codebase='A',
created_at=epoch2datetime(CREATED_AT),
patch=None,
project='proj',
repository='repo',
revision='aaa',
ssid=234,
)
]
return self.do_test_getSourceStampsForBuild(rows, 50, expected)
def test_getSourceStampsForBuild_3CodeBases(self):
rows = [
fakedb.Master(id=88, name="bar"),
fakedb.Worker(id=13, name='one'),
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, codebase='A', created_at=CREATED_AT, revision="aaa"),
fakedb.SourceStamp(id=235, codebase='B', created_at=CREATED_AT + 10, revision="bbb"),
fakedb.SourceStamp(id=236, codebase='C', created_at=CREATED_AT + 20, revision="ccc"),
# fakedb.Change(changeid=14, codebase='A', sourcestampid=234),
fakedb.Buildset(id=30, reason='foo', submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.BuildsetSourceStamp(sourcestampid=235, buildsetid=30),
fakedb.BuildsetSourceStamp(sourcestampid=236, buildsetid=30),
fakedb.BuildRequest(
id=19, buildsetid=30, builderid=77, priority=13, submitted_at=1300305712, results=-1
),
fakedb.Build(
id=50,
buildrequestid=19,
number=5,
masterid=88,
builderid=77,
state_string="test",
workerid=13,
started_at=1304262222,
),
]
expected = [
sourcestamps.SourceStampModel(
branch='master',
codebase='A',
created_at=epoch2datetime(CREATED_AT),
patch=None,
project='proj',
repository='repo',
revision='aaa',
ssid=234,
),
sourcestamps.SourceStampModel(
branch='master',
codebase='B',
created_at=epoch2datetime(CREATED_AT + 10),
patch=None,
project='proj',
repository='repo',
revision='bbb',
ssid=235,
),
sourcestamps.SourceStampModel(
branch='master',
codebase='C',
created_at=epoch2datetime(CREATED_AT + 20),
patch=None,
project='proj',
repository='repo',
revision='ccc',
ssid=236,
),
]
return self.do_test_getSourceStampsForBuild(rows, 50, expected)
class RealTests(Tests):
pass
class TestRealDB(unittest.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'sourcestamps',
'patches',
"projects",
'masters',
'workers',
'buildsets',
'builders',
'buildrequests',
'buildset_sourcestamps',
'builds',
]
)
self.db.sourcestamps = sourcestamps.SourceStampsConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
| 19,873 | Python | .py | 516 | 25.604651 | 100 | 0.549886 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,424 | test_schedulers.py | buildbot_buildbot/master/buildbot/test/unit/db/test_schedulers.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from buildbot.db import schedulers
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import db
from buildbot.test.util import interfaces
class Tests(interfaces.InterfaceTests):
# test data
ss92 = fakedb.SourceStamp(id=92)
change3 = fakedb.Change(changeid=3)
change4 = fakedb.Change(changeid=4)
change5 = fakedb.Change(changeid=5)
change6 = fakedb.Change(changeid=6, branch='sql')
scheduler24 = fakedb.Scheduler(id=24, name='schname')
master13 = fakedb.Master(id=13, name='m1', active=1)
scheduler24master = fakedb.SchedulerMaster(schedulerid=24, masterid=13)
scheduler25 = fakedb.Scheduler(id=25, name='schname2')
master14 = fakedb.Master(id=14, name='m2', active=0)
scheduler25master = fakedb.SchedulerMaster(schedulerid=25, masterid=14)
# tests
def test_signature_enable(self):
@self.assertArgSpecMatches(self.db.schedulers.enable)
def enable(self, schedulerid, v):
pass
@defer.inlineCallbacks
def test_enable(self):
yield self.insert_test_data([self.scheduler24, self.master13, self.scheduler24master])
sch = yield self.db.schedulers.getScheduler(24)
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sch, schedulers.SchedulerModel(id=24, name='schname', enabled=True, masterid=13)
)
yield self.db.schedulers.enable(24, False)
sch = yield self.db.schedulers.getScheduler(24)
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sch, schedulers.SchedulerModel(id=24, name='schname', enabled=False, masterid=13)
)
yield self.db.schedulers.enable(24, True)
sch = yield self.db.schedulers.getScheduler(24)
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sch, schedulers.SchedulerModel(id=24, name='schname', enabled=True, masterid=13)
)
def test_signature_classifyChanges(self):
@self.assertArgSpecMatches(self.db.schedulers.classifyChanges)
def classifyChanges(self, schedulerid, classifications):
pass
@defer.inlineCallbacks
def test_classifyChanges(self):
yield self.insert_test_data([self.ss92, self.change3, self.change4, self.scheduler24])
yield self.db.schedulers.classifyChanges(24, {3: False, 4: True})
res = yield self.db.schedulers.getChangeClassifications(24)
self.assertEqual(res, {3: False, 4: True})
@defer.inlineCallbacks
def test_classifyChanges_again(self):
# test reclassifying changes, which may happen during some timing
# conditions. It's important that this test uses multiple changes,
# only one of which already exists
yield self.insert_test_data([
self.ss92,
self.change3,
self.change4,
self.change5,
self.change6,
self.scheduler24,
fakedb.SchedulerChange(schedulerid=24, changeid=5, important=0),
])
yield self.db.schedulers.classifyChanges(24, {3: True, 4: False, 5: True, 6: False})
res = yield self.db.schedulers.getChangeClassifications(24)
self.assertEqual(res, {3: True, 4: False, 5: True, 6: False})
def test_signature_flushChangeClassifications(self):
@self.assertArgSpecMatches(self.db.schedulers.flushChangeClassifications)
def flushChangeClassifications(self, schedulerid, less_than=None):
pass
@defer.inlineCallbacks
def test_flushChangeClassifications(self):
yield self.insert_test_data([
self.ss92,
self.change3,
self.change4,
self.change5,
self.scheduler24,
])
yield self.addClassifications(24, (3, 1), (4, 0), (5, 1))
res = yield self.db.schedulers.getChangeClassifications(24)
self.assertEqual(res, {3: True, 4: False, 5: True})
yield self.db.schedulers.flushChangeClassifications(24)
res = yield self.db.schedulers.getChangeClassifications(24)
self.assertEqual(res, {})
@defer.inlineCallbacks
def test_flushChangeClassifications_less_than(self):
yield self.insert_test_data([
self.ss92,
self.change3,
self.change4,
self.change5,
self.scheduler24,
])
yield self.addClassifications(24, (3, 1), (4, 0), (5, 1))
yield self.db.schedulers.flushChangeClassifications(24, less_than=5)
res = yield self.db.schedulers.getChangeClassifications(24)
self.assertEqual(res, {5: True})
def test_signature_getChangeClassifications(self):
@self.assertArgSpecMatches(self.db.schedulers.getChangeClassifications)
def getChangeClassifications(
self, schedulerid, branch=-1, repository=-1, project=-1, codebase=-1
):
pass
@defer.inlineCallbacks
def test_getChangeClassifications(self):
yield self.insert_test_data([
self.ss92,
self.change3,
self.change4,
self.change5,
self.change6,
self.scheduler24,
])
yield self.addClassifications(24, (3, 1), (4, 0), (5, 1), (6, 1))
res = yield self.db.schedulers.getChangeClassifications(24)
self.assertEqual(res, {3: True, 4: False, 5: True, 6: True})
@defer.inlineCallbacks
def test_getChangeClassifications_branch(self):
yield self.insert_test_data([
self.ss92,
self.change3,
self.change4,
self.change5,
self.change6,
self.scheduler24,
])
yield self.addClassifications(24, (3, 1), (4, 0), (5, 1), (6, 1))
res = yield self.db.schedulers.getChangeClassifications(24, branch='sql')
self.assertEqual(res, {6: True})
def test_signature_findSchedulerId(self):
@self.assertArgSpecMatches(self.db.schedulers.findSchedulerId)
def findSchedulerId(self, name):
pass
@defer.inlineCallbacks
def test_findSchedulerId_new(self):
id = yield self.db.schedulers.findSchedulerId('schname')
sch = yield self.db.schedulers.getScheduler(id)
self.assertEqual(sch.name, 'schname')
@defer.inlineCallbacks
def test_findSchedulerId_existing(self):
id = yield self.db.schedulers.findSchedulerId('schname')
id2 = yield self.db.schedulers.findSchedulerId('schname')
self.assertEqual(id, id2)
def test_signature_setSchedulerMaster(self):
@self.assertArgSpecMatches(self.db.schedulers.setSchedulerMaster)
def setSchedulerMaster(self, schedulerid, masterid):
pass
@defer.inlineCallbacks
def test_setSchedulerMaster_fresh(self):
yield self.insert_test_data([self.scheduler24, self.master13])
yield self.db.schedulers.setSchedulerMaster(24, 13)
sch = yield self.db.schedulers.getScheduler(24)
self.assertEqual(sch.masterid, 13)
@defer.inlineCallbacks
def test_setSchedulerMaster_inactive_but_linked(self):
d = self.insert_test_data([
self.master13,
self.scheduler25,
self.master14,
self.scheduler25master,
])
d.addCallback(lambda _: self.db.schedulers.setSchedulerMaster(25, 13))
yield self.assertFailure(d, schedulers.SchedulerAlreadyClaimedError)
@defer.inlineCallbacks
def test_setSchedulerMaster_inactive_but_linked_to_this_master(self):
yield self.insert_test_data([
self.scheduler25,
self.master14,
self.scheduler25master,
])
yield self.db.schedulers.setSchedulerMaster(25, 14)
@defer.inlineCallbacks
def test_setSchedulerMaster_active(self):
d = self.insert_test_data([
self.scheduler24,
self.master13,
self.scheduler24master,
])
d.addCallback(lambda _: self.db.schedulers.setSchedulerMaster(24, 14))
yield self.assertFailure(d, schedulers.SchedulerAlreadyClaimedError)
@defer.inlineCallbacks
def test_setSchedulerMaster_None(self):
yield self.insert_test_data([
self.scheduler25,
self.master14,
self.scheduler25master,
])
yield self.db.schedulers.setSchedulerMaster(25, None)
sch = yield self.db.schedulers.getScheduler(25)
self.assertEqual(sch.masterid, None)
@defer.inlineCallbacks
def test_setSchedulerMaster_None_unowned(self):
yield self.insert_test_data([self.scheduler25])
yield self.db.schedulers.setSchedulerMaster(25, None)
sch = yield self.db.schedulers.getScheduler(25)
self.assertEqual(sch.masterid, None)
def test_signature_getScheduler(self):
@self.assertArgSpecMatches(self.db.schedulers.getScheduler)
def getScheduler(self, schedulerid):
pass
@defer.inlineCallbacks
def test_getScheduler(self):
yield self.insert_test_data([self.scheduler24])
sch = yield self.db.schedulers.getScheduler(24)
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sch, schedulers.SchedulerModel(id=24, name='schname', enabled=True, masterid=None)
)
@defer.inlineCallbacks
def test_getScheduler_missing(self):
sch = yield self.db.schedulers.getScheduler(24)
self.assertEqual(sch, None)
@defer.inlineCallbacks
def test_getScheduler_active(self):
yield self.insert_test_data([self.scheduler24, self.master13, self.scheduler24master])
sch = yield self.db.schedulers.getScheduler(24)
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sch, schedulers.SchedulerModel(id=24, name='schname', enabled=True, masterid=13)
)
@defer.inlineCallbacks
def test_getScheduler_inactive_but_linked(self):
yield self.insert_test_data([self.scheduler25, self.master14, self.scheduler25master])
sch = yield self.db.schedulers.getScheduler(25)
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sch, schedulers.SchedulerModel(id=25, name='schname2', enabled=True, masterid=14)
) # row exists, but marked inactive
def test_signature_getSchedulers(self):
@self.assertArgSpecMatches(self.db.schedulers.getSchedulers)
def getSchedulers(self, active=None, masterid=None):
pass
@defer.inlineCallbacks
def test_getSchedulers(self):
yield self.insert_test_data([
self.scheduler24,
self.master13,
self.scheduler24master,
self.scheduler25,
])
def schKey(sch):
return sch.id
schlist = yield self.db.schedulers.getSchedulers()
for sch in schlist:
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sorted(schlist, key=schKey),
sorted(
[
schedulers.SchedulerModel(id=24, name='schname', enabled=True, masterid=13),
schedulers.SchedulerModel(id=25, name='schname2', enabled=True, masterid=None),
],
key=schKey,
),
)
@defer.inlineCallbacks
def test_getSchedulers_masterid(self):
yield self.insert_test_data([
self.scheduler24,
self.master13,
self.scheduler24master,
self.scheduler25,
])
schlist = yield self.db.schedulers.getSchedulers(masterid=13)
for sch in schlist:
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sorted(schlist),
sorted([
schedulers.SchedulerModel(id=24, name='schname', enabled=True, masterid=13),
]),
)
@defer.inlineCallbacks
def test_getSchedulers_active(self):
yield self.insert_test_data([
self.scheduler24,
self.master13,
self.scheduler24master,
self.scheduler25,
])
schlist = yield self.db.schedulers.getSchedulers(active=True)
for sch in schlist:
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sorted(schlist),
sorted([
schedulers.SchedulerModel(id=24, name='schname', enabled=True, masterid=13),
]),
)
@defer.inlineCallbacks
def test_getSchedulers_active_masterid(self):
yield self.insert_test_data([
self.scheduler24,
self.master13,
self.scheduler24master,
self.scheduler25,
])
schlist = yield self.db.schedulers.getSchedulers(active=True, masterid=13)
for sch in schlist:
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sorted(schlist),
sorted([
schedulers.SchedulerModel(id=24, name='schname', enabled=True, masterid=13),
]),
)
schlist = yield self.db.schedulers.getSchedulers(active=True, masterid=14)
for sch in schlist:
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(sorted(schlist), [])
@defer.inlineCallbacks
def test_getSchedulers_inactive(self):
yield self.insert_test_data([
self.scheduler24,
self.master13,
self.scheduler24master,
self.scheduler25,
])
schlist = yield self.db.schedulers.getSchedulers(active=False)
for sch in schlist:
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(
sorted(schlist),
sorted([
schedulers.SchedulerModel(id=25, name='schname2', enabled=True, masterid=None),
]),
)
@defer.inlineCallbacks
def test_getSchedulers_inactive_masterid(self):
yield self.insert_test_data([
self.scheduler24,
self.master13,
self.scheduler24master,
self.scheduler25,
])
schlist = yield self.db.schedulers.getSchedulers(active=False, masterid=13)
for sch in schlist:
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(sorted(schlist), [])
schlist = yield self.db.schedulers.getSchedulers(active=False, masterid=14)
for sch in schlist:
self.assertIsInstance(sch, schedulers.SchedulerModel)
self.assertEqual(sorted(schlist), []) # always returns [] by spec!
class RealTests(Tests):
# tests that only "real" implementations will pass
pass
class TestRealDB(db.TestCase, connector_component.ConnectorComponentMixin, RealTests):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(
table_names=[
'changes',
'schedulers',
'masters',
'sourcestamps',
'patches',
'scheduler_masters',
'scheduler_changes',
]
)
self.db.schedulers = schedulers.SchedulersConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
@defer.inlineCallbacks
def addClassifications(self, schedulerid, *classifications):
def thd(conn):
q = self.db.model.scheduler_changes.insert()
conn.execute(
q,
[
{"changeid": c[0], "schedulerid": schedulerid, "important": c[1]}
for c in classifications
],
)
yield self.db.pool.do_with_transaction(thd)
| 16,744 | Python | .py | 395 | 32.883544 | 99 | 0.65442 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,425 | test_state.py | buildbot_buildbot/master/buildbot/test/unit/db/test_state.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from buildbot.db import state
from buildbot.test import fakedb
from buildbot.test.util import connector_component
from buildbot.test.util import db
class TestStateConnectorComponent(connector_component.ConnectorComponentMixin, db.TestCase):
@defer.inlineCallbacks
def setUp(self):
yield self.setUpConnectorComponent(table_names=['objects', 'object_state'])
self.db.state = state.StateConnectorComponent(self.db)
def tearDown(self):
return self.tearDownConnectorComponent()
@defer.inlineCallbacks
def test_getObjectId_new(self):
objectid = yield self.db.state.getObjectId('someobj', 'someclass')
yield self.assertNotEqual(objectid, None)
def thd(conn):
q = self.db.model.objects.select()
rows = conn.execute(q).fetchall()
self.assertEqual(
[(r.id, r.name, r.class_name) for r in rows], [(objectid, 'someobj', 'someclass')]
)
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_getObjectId_existing(self):
yield self.insert_test_data([fakedb.Object(id=19, name='someobj', class_name='someclass')])
objectid = yield self.db.state.getObjectId('someobj', 'someclass')
self.assertEqual(objectid, 19)
@defer.inlineCallbacks
def test_getObjectId_conflict(self):
# set up to insert a row between looking for an existing object
# and adding a new one, triggering the fallback to re-running
# the select.
def hook(conn):
conn.execute(
self.db.model.objects.insert().values(id=27, name='someobj', class_name='someclass')
)
conn.commit()
self.db.state._test_timing_hook = hook
objectid = yield self.db.state.getObjectId('someobj', 'someclass')
self.assertEqual(objectid, 27)
@defer.inlineCallbacks
def test_getObjectId_new_big_name(self):
objectid = yield self.db.state.getObjectId('someobj' * 150, 'someclass')
expn = 'someobj' * 9 + 's132bf9b89b0cdbc040d1ebc69e0dbee85dff720a'
self.assertNotEqual(objectid, None)
def thd(conn):
q = self.db.model.objects.select()
rows = conn.execute(q).fetchall()
self.assertEqual(
[(r.id, r.name, r.class_name) for r in rows], [(objectid, expn, 'someclass')]
)
yield self.db.pool.do(thd)
def test_getState_missing(self):
d = self.db.state.getState(10, 'nosuch')
return self.assertFailure(d, KeyError)
@defer.inlineCallbacks
def test_getState_missing_default(self):
val = yield self.db.state.getState(10, 'nosuch', 'abc')
self.assertEqual(val, 'abc')
@defer.inlineCallbacks
def test_getState_missing_default_None(self):
val = yield self.db.state.getState(10, 'nosuch', None)
self.assertEqual(val, None)
@defer.inlineCallbacks
def test_getState_present(self):
yield self.insert_test_data([
fakedb.Object(id=10, name='x', class_name='y'),
fakedb.ObjectState(objectid=10, name='x', value_json='[1,2]'),
])
val = yield self.db.state.getState(10, 'x')
self.assertEqual(val, [1, 2])
def test_getState_badjson(self):
d = self.insert_test_data([
fakedb.Object(id=10, name='x', class_name='y'),
fakedb.ObjectState(objectid=10, name='x', value_json='ff[1'),
])
d.addCallback(lambda _: self.db.state.getState(10, 'x'))
return self.assertFailure(d, TypeError)
@defer.inlineCallbacks
def test_setState(self):
yield self.insert_test_data([
fakedb.Object(id=10, name='-', class_name='-'),
])
yield self.db.state.setState(10, 'x', [1, 2])
def thd(conn):
q = self.db.model.object_state.select()
rows = conn.execute(q).fetchall()
self.assertEqual(
[(r.objectid, r.name, r.value_json) for r in rows], [(10, 'x', '[1, 2]')]
)
yield self.db.pool.do(thd)
def test_setState_badjson(self):
d = self.insert_test_data([
fakedb.Object(id=10, name='x', class_name='y'),
])
d.addCallback(lambda _: self.db.state.setState(10, 'x', self)) # self is not JSON-able..
return self.assertFailure(d, TypeError)
@defer.inlineCallbacks
def test_setState_existing(self):
yield self.insert_test_data([
fakedb.Object(id=10, name='-', class_name='-'),
fakedb.ObjectState(objectid=10, name='x', value_json='99'),
])
yield self.db.state.setState(10, 'x', [1, 2])
def thd(conn):
q = self.db.model.object_state.select()
rows = conn.execute(q).fetchall()
self.assertEqual(
[(r.objectid, r.name, r.value_json) for r in rows], [(10, 'x', '[1, 2]')]
)
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_setState_conflict(self):
def hook(conn):
conn.execute(
self.db.model.object_state.insert().values(objectid=10, name='x', value_json='22')
)
conn.commit()
self.db.state._test_timing_hook = hook
yield self.insert_test_data([
fakedb.Object(id=10, name='-', class_name='-'),
])
yield self.db.state.setState(10, 'x', [1, 2])
def thd(conn):
q = self.db.model.object_state.select()
rows = conn.execute(q).fetchall()
self.assertEqual([(r.objectid, r.name, r.value_json) for r in rows], [(10, 'x', '22')])
yield self.db.pool.do(thd)
@defer.inlineCallbacks
def test_atomicCreateState(self):
yield self.insert_test_data([
fakedb.Object(id=10, name='-', class_name='-'),
])
res = yield self.db.state.atomicCreateState(10, 'x', lambda: [1, 2])
self.assertEqual(res, [1, 2])
res = yield self.db.state.getState(10, 'x')
self.assertEqual(res, [1, 2])
@defer.inlineCallbacks
def test_atomicCreateState_conflict(self):
yield self.insert_test_data([
fakedb.Object(id=10, name='-', class_name='-'),
])
def hook(conn):
conn.execute(
self.db.model.object_state.insert().values(objectid=10, name='x', value_json='22')
)
conn.commit()
self.db.state._test_timing_hook = hook
res = yield self.db.state.atomicCreateState(10, 'x', lambda: [1, 2])
self.assertEqual(res, 22)
res = yield self.db.state.getState(10, 'x')
self.assertEqual(res, 22)
@defer.inlineCallbacks
def test_atomicCreateState_nojsonable(self):
yield self.insert_test_data([
fakedb.Object(id=10, name='-', class_name='-'),
])
d = self.db.state.atomicCreateState(10, 'x', object)
yield self.assertFailure(d, TypeError)
| 7,754 | Python | .py | 174 | 35.701149 | 100 | 0.623606 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,426 | test_enginestrategy.py | buildbot_buildbot/master/buildbot/test/unit/db/test_enginestrategy.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import sqlalchemy as sa
from sqlalchemy.engine import url
from sqlalchemy.pool import NullPool
from twisted.python import runtime
from twisted.trial import unittest
from buildbot.db import enginestrategy
from buildbot.util.sautils import sa_version
class BuildbotCreateEngineTest(unittest.TestCase):
"Test the special case methods, without actually creating a db"
# used several times below
mysql_kwargs = {
"basedir": 'my-base-dir',
"connect_args": {"init_command": 'SET default_storage_engine=MyISAM'},
"pool_recycle": 3600,
}
sqlite_kwargs = {"basedir": '/my-base-dir', "poolclass": NullPool}
# utility
def filter_kwargs(self, kwargs):
# filter out the listeners list to just include the class name
if 'listeners' in kwargs:
kwargs['listeners'] = [lstnr.__class__.__name__ for lstnr in kwargs['listeners']]
return kwargs
# tests
def test_sqlite_pct_sub(self):
u = url.make_url("sqlite:///%(basedir)s/x/state.sqlite")
kwargs = {"basedir": '/my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_sqlite(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["sqlite:////my-base-dir/x/state.sqlite", 1, self.sqlite_kwargs],
)
def test_sqlite_relpath(self):
url_src = "sqlite:///x/state.sqlite"
basedir = "/my-base-dir"
expected_url = "sqlite:////my-base-dir/x/state.sqlite"
# this looks a whole lot different on windows
if runtime.platformType == 'win32':
url_src = r'sqlite:///X\STATE.SQLITE'
basedir = r'C:\MYBASE~1'
expected_url = r'sqlite:///C:\MYBASE~1\X\STATE.SQLITE'
exp_kwargs = self.sqlite_kwargs.copy()
exp_kwargs['basedir'] = basedir
u = url.make_url(url_src)
kwargs = {"basedir": basedir}
u, kwargs, max_conns = enginestrategy.special_case_sqlite(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)], [expected_url, 1, exp_kwargs]
)
def test_sqlite_abspath(self):
u = url.make_url("sqlite:////x/state.sqlite")
kwargs = {"basedir": '/my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_sqlite(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["sqlite:////x/state.sqlite", 1, self.sqlite_kwargs],
)
def test_sqlite_memory(self):
u = url.make_url("sqlite://")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_sqlite(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
[
"sqlite://",
1, # only one conn at a time
{"basedir": 'my-base-dir', "connect_args": {"check_same_thread": False}},
],
)
def test_mysql_simple(self):
u = url.make_url("mysql://host/dbname")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_mysql(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["mysql://host/dbname?charset=utf8&use_unicode=True", None, self.mysql_kwargs],
)
def test_mysql_userport(self):
u = url.make_url("mysql://user:pass@host:1234/dbname")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_mysql(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
[
(
"mysql://user:pass@host:1234/dbname?charset=utf8&use_unicode=True"
if sa_version()[0] < 2
else "mysql://user:***@host:1234/dbname?charset=utf8&use_unicode=True"
),
None,
self.mysql_kwargs,
],
)
def test_mysql_local(self):
u = url.make_url("mysql:///dbname")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_mysql(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["mysql:///dbname?charset=utf8&use_unicode=True", None, self.mysql_kwargs],
)
def test_mysql_args(self):
u = url.make_url("mysql:///dbname?foo=bar")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_mysql(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["mysql:///dbname?charset=utf8&foo=bar&use_unicode=True", None, self.mysql_kwargs],
)
def test_mysql_max_idle(self):
u = url.make_url("mysql:///dbname?max_idle=1234")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_mysql(u, kwargs)
exp = self.mysql_kwargs.copy()
exp['pool_recycle'] = 1234
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["mysql:///dbname?charset=utf8&use_unicode=True", None, exp],
)
def test_mysql_good_charset(self):
u = url.make_url("mysql:///dbname?charset=utf8")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_mysql(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["mysql:///dbname?charset=utf8&use_unicode=True", None, self.mysql_kwargs],
)
def test_mysql_bad_charset(self):
u = url.make_url("mysql:///dbname?charset=ebcdic")
kwargs = {"basedir": 'my-base-dir'}
with self.assertRaises(TypeError):
enginestrategy.special_case_mysql(u, kwargs)
def test_mysql_good_use_unicode(self):
u = url.make_url("mysql:///dbname?use_unicode=True")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_mysql(u, kwargs)
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["mysql:///dbname?charset=utf8&use_unicode=True", None, self.mysql_kwargs],
)
def test_mysql_bad_use_unicode(self):
u = url.make_url("mysql:///dbname?use_unicode=maybe")
kwargs = {"basedir": 'my-base-dir'}
with self.assertRaises(TypeError):
enginestrategy.special_case_mysql(u, kwargs)
def test_mysql_storage_engine(self):
u = url.make_url("mysql:///dbname?storage_engine=foo")
kwargs = {"basedir": 'my-base-dir'}
u, kwargs, max_conns = enginestrategy.special_case_mysql(u, kwargs)
exp = self.mysql_kwargs.copy()
exp['connect_args'] = {"init_command": 'SET default_storage_engine=foo'}
self.assertEqual(
[str(u), max_conns, self.filter_kwargs(kwargs)],
["mysql:///dbname?charset=utf8&use_unicode=True", None, exp],
)
class BuildbotEngineStrategy(unittest.TestCase):
"Test create_engine by creating a sqlite in-memory db"
def test_create_engine(self):
engine = enginestrategy.create_engine('sqlite://', basedir="/base")
try:
with engine.connect() as conn:
self.assertEqual(conn.scalar(sa.text("SELECT 13 + 14")), 27)
finally:
engine.dispose()
| 8,198 | Python | .py | 177 | 37.429379 | 95 | 0.615539 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,427 | test_master.py | buildbot_buildbot/master/buildbot/test/unit/config/test_master.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import builtins
import os
import re
import textwrap
from unittest import mock
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from zope.interface import implementer
from buildbot import config
from buildbot import configurators
from buildbot import interfaces
from buildbot import locks
from buildbot import revlinks
from buildbot import worker
from buildbot.changes import base as changes_base
from buildbot.config.errors import capture_config_errors
from buildbot.config.master import FileLoader
from buildbot.config.master import loadConfigDict
from buildbot.process import factory
from buildbot.process import properties
from buildbot.schedulers import base as schedulers_base
from buildbot.test.util import dirs
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.warnings import assertNotProducesWarnings
from buildbot.test.util.warnings import assertProducesWarning
from buildbot.util import service
from buildbot.warnings import ConfigWarning
from buildbot.warnings import DeprecatedApiWarning
global_defaults = {
"title": 'Buildbot',
"titleURL": 'http://buildbot.net/',
"buildbotURL": 'http://localhost:8080/',
"logCompressionLimit": 4096,
"logCompressionMethod": 'zstd',
"logEncoding": 'utf-8',
"logMaxTailSize": None,
"logMaxSize": None,
"properties": properties.Properties(),
"collapseRequests": None,
"prioritizeBuilders": None,
"select_next_worker": None,
"protocols": {},
"multiMaster": False,
"manhole": None,
# in unit tests we default to None, but normally defaults to 'basic'
"buildbotNetUsageData": None,
"www": {
"port": None,
"plugins": {},
"auth": {'name': 'NoAuth'},
"authz": {},
"avatar_methods": {'name': 'gravatar'},
"logfileName": 'http.log',
},
}
class FakeChangeSource(changes_base.ChangeSource):
def __init__(self):
super().__init__(name='FakeChangeSource')
@implementer(interfaces.IScheduler)
class FakeScheduler:
def __init__(self, name):
self.name = name
class FakeBuilder:
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
@implementer(interfaces.IWorker)
class FakeWorker:
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
@implementer(interfaces.IMachine)
class FakeMachine:
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
class ConfigLoaderTests(ConfigErrorsMixin, dirs.DirsMixin, unittest.SynchronousTestCase):
def setUp(self):
self.basedir = os.path.abspath('basedir')
self.filename = os.path.join(self.basedir, 'test.cfg')
self.patch(config.master, "get_is_in_unit_tests", lambda: False)
return self.setUpDirs('basedir')
def tearDown(self):
return self.tearDownDirs()
def install_config_file(self, config_file, other_files=None):
if other_files is None:
other_files = {}
config_file = textwrap.dedent(config_file)
with open(os.path.join(self.basedir, self.filename), "w", encoding='utf-8') as f:
f.write(config_file)
for file, contents in other_files.items():
with open(file, "w", encoding='utf-8') as f:
f.write(contents)
def test_loadConfig_missing_file(self):
with self.assertRaisesConfigError(re.compile("configuration file .* does not exist")):
loadConfigDict(self.basedir, self.filename)
def test_loadConfig_missing_basedir(self):
with self.assertRaisesConfigError(re.compile("basedir .* does not exist")):
loadConfigDict(os.path.join(self.basedir, 'NO'), 'test.cfg')
def test_loadConfig_open_error(self):
"""
Check that loadConfig() raises correct ConfigError exception in cases
when configure file is found, but we fail to open it.
"""
def raise_IOError(*args, **kwargs):
raise OSError("error_msg")
self.install_config_file('#dummy')
# override build-in open() function to always rise IOError
self.patch(builtins, "open", raise_IOError)
# check that we got the expected ConfigError exception
with self.assertRaisesConfigError(
re.compile("unable to open configuration file .*: error_msg")
):
loadConfigDict(self.basedir, self.filename)
def test_loadConfig_parse_error(self):
self.install_config_file('def x:\nbar')
with self.assertRaisesConfigError(
re.compile("encountered a SyntaxError while parsing config file:")
):
loadConfigDict(self.basedir, self.filename)
def test_loadConfig_eval_ConfigError(self):
self.install_config_file("""\
from buildbot import config
BuildmasterConfig = { 'multiMaster': True }
config.error('oh noes!')""")
with self.assertRaisesConfigError("oh noes"):
loadConfigDict(self.basedir, self.filename)
def test_loadConfig_eval_otherError(self):
self.install_config_file("""\
from buildbot import config
BuildmasterConfig = { 'multiMaster': True }
raise ValueError('oh noes')""")
with self.assertRaisesConfigError(
"error while parsing config file: oh noes (traceback in logfile)"
):
loadConfigDict(self.basedir, self.filename)
[error] = self.flushLoggedErrors(ValueError)
self.assertEqual(error.value.args, ("oh noes",))
def test_loadConfig_no_BuildmasterConfig(self):
self.install_config_file('x=10')
with self.assertRaisesConfigError("does not define 'BuildmasterConfig'"):
loadConfigDict(self.basedir, self.filename)
def test_loadConfig_with_local_import(self):
self.install_config_file(
"""\
from subsidiary_module import x
BuildmasterConfig = dict(x=x)
""",
{'basedir/subsidiary_module.py': "x = 10"},
)
_, rv = loadConfigDict(self.basedir, self.filename)
self.assertEqual(rv, {'x': 10})
class MasterConfigTests(ConfigErrorsMixin, dirs.DirsMixin, unittest.TestCase):
maxDiff = None
def setUp(self):
self.basedir = os.path.abspath('basedir')
self.filename = os.path.join(self.basedir, 'test.cfg')
return self.setUpDirs('basedir')
def tearDown(self):
return self.tearDownDirs()
# utils
def patch_load_helpers(self):
# patch out all of the "helpers" for loadConfig with null functions
for n in dir(config.master.MasterConfig):
if n.startswith('load_'):
typ = 'loader'
elif n.startswith('check_'):
typ = 'checker'
else:
continue
v = getattr(config.master.MasterConfig, n)
if callable(v):
if typ == 'loader':
self.patch(
config.master.MasterConfig,
n,
mock.Mock(side_effect=lambda filename, config_dict: None),
)
else:
self.patch(config.master.MasterConfig, n, mock.Mock(side_effect=lambda: None))
def install_config_file(self, config_file, other_files=None):
if other_files is None:
other_files = {}
config_file = textwrap.dedent(config_file)
with open(os.path.join(self.basedir, self.filename), "w", encoding='utf-8') as f:
f.write(config_file)
for file, contents in other_files.items():
with open(file, "w", encoding='utf-8') as f:
f.write(contents)
# tests
def test_defaults(self):
cfg = config.master.MasterConfig()
expected = {
# validation,
"db": {"db_url": 'sqlite:///state.sqlite'},
"mq": {"type": 'simple'},
"metrics": None,
"caches": {"Changes": 10, "Builds": 15},
"schedulers": {},
"builders": [],
"workers": [],
"change_sources": [],
"status": [],
"user_managers": [],
"revlink": revlinks.default_revlink_matcher,
}
expected.update(global_defaults)
expected['buildbotNetUsageData'] = 'basic'
got = {attr: getattr(cfg, attr) for attr, exp in expected.items()}
got = interfaces.IConfigured(got).getConfigDict()
expected = interfaces.IConfigured(expected).getConfigDict()
self.assertEqual(got, expected)
def test_defaults_validation(self):
# re's aren't comparable, but we can make sure the keys match
cfg = config.master.MasterConfig()
self.assertEqual(
sorted(cfg.validation.keys()),
sorted([
'branch',
'revision',
'property_name',
'property_value',
]),
)
def test_loadConfig_eval_ConfigErrors(self):
# We test a config that has embedded errors, as well
# as semantic errors that get added later. If an exception is raised
# prematurely, then the semantic errors wouldn't get reported.
self.install_config_file("""\
from buildbot import config
BuildmasterConfig = {}
config.error('oh noes!')
config.error('noes too!')""")
with capture_config_errors() as errors:
FileLoader(self.basedir, self.filename).loadConfig()
self.assertEqual(
errors.errors,
['oh noes!', 'noes too!', 'no workers are configured', 'no builders are configured'],
)
def test_loadConfig_unknown_key(self):
self.patch_load_helpers()
self.install_config_file("""\
BuildmasterConfig = dict(foo=10)
""")
with self.assertRaisesConfigError("Unknown BuildmasterConfig key foo"):
FileLoader(self.basedir, self.filename).loadConfig()
def test_loadConfig_unknown_keys(self):
self.patch_load_helpers()
self.install_config_file("""\
BuildmasterConfig = dict(foo=10, bar=20)
""")
with self.assertRaisesConfigError("Unknown BuildmasterConfig keys bar, foo"):
FileLoader(self.basedir, self.filename).loadConfig()
def test_loadConfig_success(self):
self.patch_load_helpers()
self.install_config_file("""\
BuildmasterConfig = dict()
""")
rv = FileLoader(self.basedir, self.filename).loadConfig()
self.assertIsInstance(rv, config.master.MasterConfig)
# make sure all of the loaders and checkers are called
self.assertTrue(rv.load_global.called)
self.assertTrue(rv.load_validation.called)
self.assertTrue(rv.load_db.called)
self.assertTrue(rv.load_metrics.called)
self.assertTrue(rv.load_caches.called)
self.assertTrue(rv.load_schedulers.called)
self.assertTrue(rv.load_builders.called)
self.assertTrue(rv.load_workers.called)
self.assertTrue(rv.load_change_sources.called)
self.assertTrue(rv.load_machines.called)
self.assertTrue(rv.load_user_managers.called)
self.assertTrue(rv.check_single_master.called)
self.assertTrue(rv.check_schedulers.called)
self.assertTrue(rv.check_locks.called)
self.assertTrue(rv.check_builders.called)
self.assertTrue(rv.check_ports.called)
self.assertTrue(rv.check_machines.called)
def test_preChangeGenerator(self):
cfg = config.master.MasterConfig()
self.assertEqual(
{
'author': None,
'files': None,
'comments': None,
'revision': None,
'when_timestamp': None,
'branch': None,
'category': None,
'revlink': '',
'properties': {},
'repository': '',
'project': '',
'codebase': None,
},
cfg.preChangeGenerator(),
)
class MasterConfig_loaders(ConfigErrorsMixin, unittest.TestCase):
filename = 'test.cfg'
def setUp(self):
self.cfg = config.master.MasterConfig()
# utils
def assertResults(self, **expected):
got = {attr: getattr(self.cfg, attr) for attr, exp in expected.items()}
got = interfaces.IConfigured(got).getConfigDict()
expected = interfaces.IConfigured(expected).getConfigDict()
self.assertEqual(got, expected)
# tests
def test_load_global_defaults(self):
self.maxDiff = None
self.cfg.load_global(self.filename, {})
self.assertResults(**global_defaults)
def test_load_global_string_param_not_string(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {"title": 10})
self.assertConfigError(errors, 'must be a string')
def test_load_global_int_param_not_int(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'changeHorizon': 'yes'})
self.assertConfigError(errors, 'must be an int')
def test_load_global_protocols_not_dict(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'protocols': "test"})
self.assertConfigError(errors, "c['protocols'] must be dict")
def test_load_global_protocols_key_int(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'protocols': {321: {"port": 123}}})
self.assertConfigError(errors, "c['protocols'] keys must be strings")
def test_load_global_protocols_value_not_dict(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'protocols': {"pb": 123}})
self.assertConfigError(errors, "c['protocols']['pb'] must be a dict")
def do_test_load_global(self, config_dict, **expected):
self.cfg.load_global(self.filename, config_dict)
self.assertResults(**expected)
def test_load_global_title(self):
self.do_test_load_global({"title": 'hi'}, title='hi')
def test_load_global_title_too_long(self):
with assertProducesWarning(ConfigWarning, message_pattern=r"Title is too long"):
self.do_test_load_global({"title": "Very very very very very long title"})
def test_load_global_titleURL(self):
self.do_test_load_global({"titleURL": 'hi'}, titleURL='hi/')
def test_load_global_buildbotURL(self):
self.do_test_load_global({"buildbotURL": 'hey'}, buildbotURL='hey/')
def test_load_global_changeHorizon(self):
self.do_test_load_global({"changeHorizon": 10}, changeHorizon=10)
def test_load_global_changeHorizon_none(self):
self.do_test_load_global({"changeHorizo": None}, changeHorizon=None)
def test_load_global_buildbotNetUsageData(self):
self.patch(config.master, "get_is_in_unit_tests", lambda: False)
with assertProducesWarning(
ConfigWarning,
message_pattern=r"`buildbotNetUsageData` is not configured and defaults to basic.",
):
self.do_test_load_global({})
def test_load_global_logCompressionLimit(self):
self.do_test_load_global({"logCompressionLimit": 10}, logCompressionLimit=10)
def test_load_global_logCompressionMethod(self):
self.do_test_load_global({"logCompressionMethod": 'bz2'}, logCompressionMethod='bz2')
def test_load_global_logCompressionMethod_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'logCompressionMethod': 'foo'})
self.assertConfigError(
errors, "c['logCompressionMethod'] must be 'raw', 'bz2', 'gz', 'lz4', 'br' or 'zstd'"
)
def test_load_global_codebaseGenerator(self):
func = lambda _: "dummy"
self.do_test_load_global({"codebaseGenerator": func}, codebaseGenerator=func)
def test_load_global_codebaseGenerator_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'codebaseGenerator': 'dummy'})
self.assertConfigError(
errors, "codebaseGenerator must be a callable accepting a dict and returning a str"
)
def test_load_global_logMaxSize(self):
self.do_test_load_global({"logMaxSize": 123}, logMaxSize=123)
def test_load_global_logMaxTailSize(self):
self.do_test_load_global({"logMaxTailSize": 123}, logMaxTailSize=123)
def test_load_global_logEncoding(self):
self.do_test_load_global({"logEncoding": 'latin-2'}, logEncoding='latin-2')
def test_load_global_properties(self):
exp = properties.Properties()
exp.setProperty('x', 10, self.filename)
self.do_test_load_global({"properties": {"x": 10}}, properties=exp)
def test_load_global_properties_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'properties': 'yes'})
self.assertConfigError(errors, "must be a dictionary")
def test_load_global_collapseRequests_bool(self):
self.do_test_load_global({"collapseRequests": False}, collapseRequests=False)
def test_load_global_collapseRequests_callable(self):
callable = lambda: None
self.do_test_load_global({"collapseRequests": callable}, collapseRequests=callable)
def test_load_global_collapseRequests_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'collapseRequests': 'yes'})
self.assertConfigError(errors, "must be a callable, True, or False")
def test_load_global_prioritizeBuilders_callable(self):
callable = lambda: None
self.do_test_load_global({"prioritizeBuilders": callable}, prioritizeBuilders=callable)
def test_load_global_prioritizeBuilders_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'prioritizeBuilders': 'yes'})
self.assertConfigError(errors, "must be a callable")
def test_load_global_select_next_worker_callable(self):
callable = lambda: None
self.do_test_load_global({"select_next_worker": callable}, select_next_worker=callable)
def test_load_global_select_next_worker_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {"select_next_worker": "yes"})
self.assertConfigError(errors, "must be a callable")
def test_load_global_protocols_str(self):
self.do_test_load_global(
{"protocols": {'pb': {'port': 'udp:123'}}}, protocols={'pb': {'port': 'udp:123'}}
)
def test_load_global_multiMaster(self):
self.do_test_load_global({"multiMaster": 1}, multiMaster=1)
def test_load_global_manhole(self):
mh = mock.Mock(name='manhole')
self.do_test_load_global({"manhole": mh}, manhole=mh)
def test_load_global_revlink_callable(self):
callable = lambda: None
self.do_test_load_global({"revlink": callable}, revlink=callable)
def test_load_global_revlink_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_global(self.filename, {'revlink': ''})
self.assertConfigError(errors, "must be a callable")
def test_load_validation_defaults(self):
self.cfg.load_validation(self.filename, {})
self.assertEqual(
sorted(self.cfg.validation.keys()),
sorted([
'branch',
'revision',
'property_name',
'property_value',
]),
)
def test_load_validation_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_validation(self.filename, {'validation': 'plz'})
self.assertConfigError(errors, "must be a dictionary")
def test_load_validation_unk_keys(self):
with capture_config_errors() as errors:
self.cfg.load_validation(self.filename, {'validation': {'users': '.*'}})
self.assertConfigError(errors, "unrecognized validation key(s)")
def test_load_validation(self):
r = re.compile('.*')
self.cfg.load_validation(self.filename, {"validation": {"branch": r}})
self.assertEqual(self.cfg.validation['branch'], r)
# check that defaults are still around
self.assertIn('revision', self.cfg.validation)
def test_load_db_defaults(self):
self.cfg.load_db(self.filename, {})
self.assertResults(db={"db_url": 'sqlite:///state.sqlite'})
def test_load_db_db_url(self):
self.cfg.load_db(self.filename, {"db_url": 'abcd'})
self.assertResults(db={"db_url": 'abcd'})
def test_load_db_dict(self):
self.cfg.load_db(self.filename, {'db': {'db_url': 'abcd'}})
self.assertResults(db={"db_url": 'abcd'})
def test_load_db_unk_keys(self):
with capture_config_errors() as errors:
self.cfg.load_db(self.filename, {'db': {'db_url': 'abcd', 'bar': 'bar'}})
self.assertConfigError(errors, "unrecognized keys in")
def test_load_mq_defaults(self):
self.cfg.load_mq(self.filename, {})
self.assertResults(mq={"type": 'simple'})
def test_load_mq_explicit_type(self):
self.cfg.load_mq(self.filename, {"mq": {"type": 'simple'}})
self.assertResults(mq={"type": 'simple'})
def test_load_mq_unk_type(self):
with capture_config_errors() as errors:
self.cfg.load_mq(self.filename, {'mq': {'type': 'foo'}})
self.assertConfigError(errors, "mq type 'foo' is not known")
def test_load_mq_unk_keys(self):
with capture_config_errors() as errors:
self.cfg.load_mq(self.filename, {'mq': {'bar': 'bar'}})
self.assertConfigError(errors, "unrecognized keys in")
def test_load_metrics_defaults(self):
self.cfg.load_metrics(self.filename, {})
self.assertResults(metrics=None)
def test_load_metrics_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_metrics(self.filename, {'metrics': 13})
self.assertConfigError(errors, "must be a dictionary")
def test_load_metrics(self):
self.cfg.load_metrics(self.filename, {"metrics": {"foo": 1}})
self.assertResults(metrics={"foo": 1})
def test_load_caches_defaults(self):
self.cfg.load_caches(self.filename, {})
self.assertResults(caches={"Changes": 10, "Builds": 15})
def test_load_caches_invalid(self):
with capture_config_errors() as errors:
self.cfg.load_caches(self.filename, {'caches': 13})
self.assertConfigError(errors, "must be a dictionary")
def test_load_caches_buildCacheSize(self):
self.cfg.load_caches(self.filename, {"buildCacheSize": 13})
self.assertResults(caches={"Builds": 13, "Changes": 10})
def test_load_caches_buildCacheSize_and_caches(self):
with capture_config_errors() as errors:
self.cfg.load_caches(self.filename, {'buildCacheSize': 13, 'caches': {'builds': 11}})
self.assertConfigError(errors, "cannot specify")
def test_load_caches_changeCacheSize(self):
self.cfg.load_caches(self.filename, {"changeCacheSize": 13})
self.assertResults(caches={"Changes": 13, "Builds": 15})
def test_load_caches_changeCacheSize_and_caches(self):
with capture_config_errors() as errors:
self.cfg.load_caches(self.filename, {'changeCacheSize': 13, 'caches': {'changes': 11}})
self.assertConfigError(errors, "cannot specify")
def test_load_caches(self):
self.cfg.load_caches(self.filename, {"caches": {"foo": 1}})
self.assertResults(caches={"Changes": 10, "Builds": 15, "foo": 1})
def test_load_caches_not_int_err(self):
"""
Test that non-integer cache sizes are not allowed.
"""
with capture_config_errors() as errors:
self.cfg.load_caches(self.filename, {'caches': {'foo': "1"}})
self.assertConfigError(errors, "value for cache size 'foo' must be an integer")
def test_load_caches_to_small_err(self):
"""
Test that cache sizes less then 1 are not allowed.
"""
with capture_config_errors() as errors:
self.cfg.load_caches(self.filename, {'caches': {'Changes': -12}})
self.assertConfigError(errors, "'Changes' cache size must be at least 1, got '-12'")
def test_load_schedulers_defaults(self):
self.cfg.load_schedulers(self.filename, {})
self.assertResults(schedulers={})
def test_load_schedulers_not_list(self):
with capture_config_errors() as errors:
self.cfg.load_schedulers(self.filename, {'schedulers': {}})
self.assertConfigError(errors, "must be a list of")
def test_load_schedulers_not_instance(self):
with capture_config_errors() as errors:
self.cfg.load_schedulers(self.filename, {'schedulers': [mock.Mock()]})
self.assertConfigError(errors, "must be a list of")
def test_load_schedulers_dupe(self):
with capture_config_errors() as errors:
sch1 = FakeScheduler(name='sch')
sch2 = FakeScheduler(name='sch')
self.cfg.load_schedulers(self.filename, {'schedulers': [sch1, sch2]})
self.assertConfigError(errors, "scheduler name 'sch' used multiple times")
def test_load_schedulers(self):
sch = schedulers_base.BaseScheduler('sch', [""])
self.cfg.load_schedulers(self.filename, {"schedulers": [sch]})
self.assertResults(schedulers={"sch": sch})
def test_load_builders_defaults(self):
self.cfg.load_builders(self.filename, {})
self.assertResults(builders=[])
def test_load_builders_not_list(self):
with capture_config_errors() as errors:
self.cfg.load_builders(self.filename, {'builders': {}})
self.assertConfigError(errors, "must be a list")
def test_load_builders_not_instance(self):
with capture_config_errors() as errors:
self.cfg.load_builders(self.filename, {'builders': [mock.Mock()]})
self.assertConfigError(errors, "is not a builder config (in c['builders']")
def test_load_builders(self):
bldr = config.BuilderConfig(name='x', factory=factory.BuildFactory(), workername='x')
self.cfg.load_builders(self.filename, {"builders": [bldr]})
self.assertResults(builders=[bldr])
def test_load_builders_dict(self):
bldr = {"name": 'x', "factory": factory.BuildFactory(), "workername": 'x'}
self.cfg.load_builders(self.filename, {"builders": [bldr]})
self.assertIsInstance(self.cfg.builders[0], config.BuilderConfig)
self.assertEqual(self.cfg.builders[0].name, 'x')
def test_load_builders_abs_builddir(self):
bldr = {
"name": 'x',
"factory": factory.BuildFactory(),
"workername": 'x',
"builddir": os.path.abspath('.'),
}
self.cfg.load_builders(self.filename, {"builders": [bldr]})
self.assertEqual(len(self.flushWarnings([self.cfg.load_builders])), 1)
def test_load_workers_defaults(self):
self.cfg.load_workers(self.filename, {})
self.assertResults(workers=[])
def test_load_workers_not_list(self):
with capture_config_errors() as errors:
self.cfg.load_workers(self.filename, {'workers': {}})
self.assertConfigError(errors, "must be a list")
def test_load_workers_not_instance(self):
with capture_config_errors() as errors:
self.cfg.load_workers(self.filename, {'workers': [mock.Mock()]})
self.assertConfigError(errors, "must be a list of")
@parameterized.expand(['debug', 'change', 'status'])
def test_load_workers_reserved_names(self, worker_name):
with capture_config_errors() as errors:
self.cfg.load_workers(self.filename, {'workers': [worker.Worker(worker_name, 'x')]})
self.assertConfigError(errors, "is reserved")
@parameterized.expand([
('initial_digits', "123_text_text"),
("spaces", "text text"),
("slash", "a/b"),
("dot", "a.b"),
])
def test_load_workers_not_identifiers(self, name, worker_name):
with capture_config_errors() as errors:
self.cfg.load_workers(self.filename, {'workers': [worker.Worker(worker_name, 'x')]})
self.assertConfigError(errors, "is not an identifier")
def test_load_workers_too_long(self):
with capture_config_errors() as errors:
name = "a" * 51
self.cfg.load_workers(self.filename, {'workers': [worker.Worker(name, 'x')]})
self.assertConfigError(errors, "is longer than")
def test_load_workers_empty(self):
with capture_config_errors() as errors:
name = ""
self.cfg.load_workers(self.filename, {'workers': [worker.Worker(name, 'x')]})
errors.errors[:] = errors.errors[1:2] # only get necessary error
self.assertConfigError(errors, "cannot be an empty string")
def test_load_workers(self):
wrk = worker.Worker('foo', 'x')
self.cfg.load_workers(self.filename, {"workers": [wrk]})
self.assertResults(workers=[wrk])
def test_load_change_sources_defaults(self):
self.cfg.load_change_sources(self.filename, {})
self.assertResults(change_sources=[])
def test_load_change_sources_not_instance(self):
with capture_config_errors() as errors:
self.cfg.load_change_sources(self.filename, {'change_source': [mock.Mock()]})
self.assertConfigError(errors, "must be a list of")
def test_load_change_sources_single(self):
chsrc = FakeChangeSource()
self.cfg.load_change_sources(self.filename, {"change_source": chsrc})
self.assertResults(change_sources=[chsrc])
def test_load_change_sources_list(self):
chsrc = FakeChangeSource()
self.cfg.load_change_sources(self.filename, {"change_source": [chsrc]})
self.assertResults(change_sources=[chsrc])
def test_load_machines_defaults(self):
self.cfg.load_machines(self.filename, {})
self.assertResults(machines=[])
def test_load_machines_not_instance(self):
with capture_config_errors() as errors:
self.cfg.load_machines(self.filename, {'machines': [mock.Mock()]})
self.assertConfigError(errors, "must be a list of")
def test_load_machines_single(self):
with capture_config_errors() as errors:
mm = FakeMachine(name='a')
self.cfg.load_machines(self.filename, {'machines': mm})
self.assertConfigError(errors, "must be a list of")
def test_load_machines_list(self):
mm = FakeMachine()
self.cfg.load_machines(self.filename, {"machines": [mm]})
self.assertResults(machines=[mm])
def test_load_user_managers_defaults(self):
self.cfg.load_user_managers(self.filename, {})
self.assertResults(user_managers=[])
def test_load_user_managers_not_list(self):
with capture_config_errors() as errors:
self.cfg.load_user_managers(self.filename, {'user_managers': 'foo'})
self.assertConfigError(errors, "must be a list")
def test_load_user_managers(self):
um = mock.Mock()
self.cfg.load_user_managers(self.filename, {"user_managers": [um]})
self.assertResults(user_managers=[um])
def test_load_www_default(self):
self.cfg.load_www(self.filename, {})
self.assertResults(
www={
"port": None,
"plugins": {},
"auth": {'name': 'NoAuth'},
"authz": {},
"avatar_methods": {'name': 'gravatar'},
"logfileName": 'http.log',
}
)
def test_load_www_port(self):
self.cfg.load_www(self.filename, {"www": {"port": 9888}})
self.assertResults(
www={
"port": 9888,
"plugins": {},
"auth": {'name': 'NoAuth'},
"authz": {},
"avatar_methods": {'name': 'gravatar'},
"logfileName": 'http.log',
}
)
def test_load_www_plugin(self):
self.cfg.load_www(self.filename, {"www": {"plugins": {'waterfall': {'foo': 'bar'}}}})
self.assertResults(
www={
"port": None,
"plugins": {'waterfall': {'foo': 'bar'}},
"auth": {'name': 'NoAuth'},
"authz": {},
"avatar_methods": {'name': 'gravatar'},
"logfileName": 'http.log',
}
)
def test_load_www_allowed_origins(self):
self.cfg.load_www(self.filename, {"www": {"allowed_origins": ['a', 'b']}})
self.assertResults(
www={
"port": None,
"allowed_origins": ['a', 'b'],
"plugins": {},
"auth": {'name': 'NoAuth'},
"authz": {},
"avatar_methods": {'name': 'gravatar'},
"logfileName": 'http.log',
}
)
def test_load_www_logfileName(self):
self.cfg.load_www(self.filename, {"www": {"logfileName": 'http-access.log'}})
self.assertResults(
www={
"port": None,
"plugins": {},
"auth": {'name': 'NoAuth'},
"authz": {},
"avatar_methods": {'name': 'gravatar'},
"logfileName": 'http-access.log',
}
)
def test_load_www_versions(self):
custom_versions = [
('Test Custom Component', '0.0.1'),
('Test Custom Component 2', '0.1.0'),
]
self.cfg.load_www(self.filename, {'www': {"versions": custom_versions}})
self.assertResults(
www={
"port": None,
"plugins": {},
"auth": {'name': 'NoAuth'},
"authz": {},
"avatar_methods": {'name': 'gravatar'},
"versions": custom_versions,
"logfileName": 'http.log',
}
)
def test_load_www_versions_not_list(self):
with capture_config_errors() as errors:
custom_versions = {
'Test Custom Component': '0.0.1',
'Test Custom Component 2': '0.0.2',
}
self.cfg.load_www(self.filename, {'www': {'versions': custom_versions}})
self.assertConfigError(errors, 'Invalid www configuration value of versions')
def test_load_www_versions_value_invalid(self):
with capture_config_errors() as errors:
custom_versions = [('a', '1'), 'abc', ('b',)]
self.cfg.load_www(self.filename, {'www': {'versions': custom_versions}})
self.assertConfigError(errors, 'Invalid www configuration value of versions')
def test_load_www_cookie_expiration_time_not_timedelta(self):
with capture_config_errors() as errors:
self.cfg.load_www(self.filename, {'www': {"cookie_expiration_time": 1}})
self.assertConfigError(errors, 'Invalid www["cookie_expiration_time"]')
def test_load_www_unknown(self):
with capture_config_errors() as errors:
self.cfg.load_www(self.filename, {"www": {"foo": "bar"}})
self.assertConfigError(errors, "unknown www configuration parameter(s) foo")
def test_load_services_nominal(self):
testcase = self
class MyService(service.BuildbotService):
def reconfigService(self, foo=None):
testcase.foo = foo
myService = MyService(foo="bar", name="foo")
self.cfg.load_services(self.filename, {"services": [myService]})
self.assertResults(services={"foo": myService})
def test_load_services_badservice(self):
class MyService:
pass
with capture_config_errors() as errors:
myService = MyService()
self.cfg.load_services(self.filename, {'services': [myService]})
errMsg = (
"<class 'buildbot.test.unit.config.test_master."
"MasterConfig_loaders.test_load_services_badservice."
"<locals>.MyService'> "
)
errMsg += "object should be an instance of buildbot.util.service.BuildbotService"
self.assertConfigError(errors, errMsg)
def test_load_services_duplicate(self):
with capture_config_errors() as errors:
class MyService(service.BuildbotService):
name = 'myservice'
def reconfigService(self, x=None):
self.x = x
self.cfg.load_services(
self.filename, {"services": [MyService(x='a'), MyService(x='b')]}
)
self.assertConfigError(errors, f'Duplicate service name {MyService.name!r}')
def test_load_configurators_norminal(self):
class MyConfigurator(configurators.ConfiguratorBase):
def configure(self, config_dict):
config_dict['foo'] = 'bar'
c = {"configurators": [MyConfigurator()]}
self.cfg.run_configurators(self.filename, c)
self.assertEqual(c['foo'], 'bar')
class MasterConfig_checkers(ConfigErrorsMixin, unittest.TestCase):
def setUp(self):
self.cfg = config.master.MasterConfig()
# utils
def setup_basic_attrs(self):
# set up a basic config for checking; this will be modified below
sch = mock.Mock()
sch.name = 'sch'
sch.listBuilderNames = lambda: ['b1', 'b2']
b1 = mock.Mock()
b1.name = 'b1'
b2 = mock.Mock()
b2.name = 'b2'
self.cfg.schedulers = {"sch": sch}
self.cfg.workers = [mock.Mock()]
self.cfg.builders = [b1, b2]
def setup_builder_locks(
self, builder_lock=None, dup_builder_lock=False, bare_builder_lock=False
):
"""Set-up two mocked builders with specified locks.
@type builder_lock: string or None
@param builder_lock: Name of the lock to add to first builder.
If None, no lock is added.
@type dup_builder_lock: boolean
@param dup_builder_lock: if True, add a lock with duplicate name
to the second builder
@type dup_builder_lock: boolean
@param bare_builder_lock: if True, add bare lock objects, don't wrap
them into locks.LockAccess object
"""
def bldr(name):
b = mock.Mock()
b.name = name
b.locks = []
b.factory.steps = [('cls', (), {"locks": []})]
return b
def lock(name):
lock = locks.MasterLock(name)
if bare_builder_lock:
return lock
return locks.LockAccess(lock, "counting", count=1)
b1 = bldr('b1')
b2 = bldr('b2')
self.cfg.builders = [b1, b2]
if builder_lock:
b1.locks.append(lock(builder_lock))
if dup_builder_lock:
b2.locks.append(lock(builder_lock))
# tests
def test_check_single_master_multimaster(self):
with capture_config_errors() as errors:
self.cfg.multiMaster = True
self.cfg.check_single_master()
self.assertNoConfigErrors(errors)
def test_check_single_master_no_builders(self):
with capture_config_errors() as errors:
self.setup_basic_attrs()
self.cfg.builders = []
self.cfg.check_single_master()
self.assertConfigError(errors, "no builders are configured")
def test_check_single_master_no_workers(self):
with capture_config_errors() as errors:
self.setup_basic_attrs()
self.cfg.workers = []
self.cfg.check_single_master()
self.assertConfigError(errors, "no workers are configured")
def test_check_single_master_unsch_builder(self):
with capture_config_errors() as errors:
self.setup_basic_attrs()
b3 = mock.Mock()
b3.name = 'b3'
self.cfg.builders.append(b3)
self.cfg.check_single_master()
self.assertConfigError(errors, "have no schedulers to drive them")
def test_check_single_master_renderable_builderNames(self):
with capture_config_errors() as errors:
self.setup_basic_attrs()
b3 = mock.Mock()
b3.name = 'b3'
self.cfg.builders.append(b3)
sch2 = mock.Mock()
sch2.listBuilderNames = lambda: properties.Interpolate('%(prop:foo)s')
self.cfg.schedulers['sch2'] = sch2
self.cfg.check_single_master()
self.assertNoConfigErrors(errors)
def test_check_schedulers_unknown_builder(self):
with capture_config_errors() as errors:
self.setup_basic_attrs()
del self.cfg.builders[1] # remove b2, leaving b1
self.cfg.check_schedulers()
self.assertConfigError(errors, "Unknown builder 'b2'")
def test_check_schedulers_ignored_in_multiMaster(self):
with capture_config_errors() as errors:
self.setup_basic_attrs()
del self.cfg.builders[1] # remove b2, leaving b1
self.cfg.multiMaster = True
self.cfg.check_schedulers()
self.assertNoConfigErrors(errors)
def test_check_schedulers_renderable_builderNames(self):
with capture_config_errors() as errors:
self.setup_basic_attrs()
sch2 = mock.Mock()
sch2.listBuilderNames = lambda: properties.Interpolate('%(prop:foo)s')
self.cfg.schedulers['sch2'] = sch2
self.cfg.check_schedulers()
self.assertNoConfigErrors(errors)
def test_check_schedulers(self):
with capture_config_errors() as errors:
self.setup_basic_attrs()
self.cfg.check_schedulers()
self.assertNoConfigErrors(errors)
def test_check_locks_dup_builder_lock(self):
with capture_config_errors() as errors:
self.setup_builder_locks(builder_lock='l', dup_builder_lock=True)
self.cfg.check_locks()
self.assertConfigError(errors, "Two locks share")
def test_check_locks(self):
with capture_config_errors() as errors:
self.setup_builder_locks(builder_lock='bl')
self.cfg.check_locks()
self.assertNoConfigErrors(errors)
def test_check_locks_none(self):
# no locks in the whole config, should be fine
with capture_config_errors() as errors:
self.setup_builder_locks()
self.cfg.check_locks()
self.assertNoConfigErrors(errors)
def test_check_locks_bare(self):
# check_locks() should be able to handle bare lock object,
# lock objects that are not wrapped into LockAccess() object
with capture_config_errors() as errors:
self.setup_builder_locks(builder_lock='oldlock', bare_builder_lock=True)
self.cfg.check_locks()
self.assertNoConfigErrors(errors)
def test_check_builders_unknown_worker(self):
with capture_config_errors() as errors:
wrk = mock.Mock()
wrk.workername = 'xyz'
self.cfg.workers = [wrk]
b1 = FakeBuilder(workernames=['xyz', 'abc'], builddir='x', name='b1', project=None)
self.cfg.builders = [b1]
self.cfg.check_builders()
self.assertConfigError(errors, "builder 'b1' uses unknown workers 'abc'")
def test_check_builders_unknown_project(self):
with capture_config_errors() as errors:
wrk = mock.Mock()
wrk.name = 'proj1'
self.cfg.projects = [wrk]
b1 = FakeBuilder(workernames=[], builddir='x', name='b1', project='proj_unknown')
self.cfg.builders = [b1]
self.cfg.check_builders()
self.assertConfigError(errors, "builder 'b1' uses unknown project name 'proj_unknown'")
def test_check_builders_duplicate_name(self):
with capture_config_errors() as errors:
b1 = FakeBuilder(workernames=[], name='b1', builddir='1', project=None)
b2 = FakeBuilder(workernames=[], name='b1', builddir='2', project=None)
self.cfg.builders = [b1, b2]
self.cfg.check_builders()
self.assertConfigError(errors, "duplicate builder name 'b1'")
def test_check_builders_duplicate_builddir(self):
with capture_config_errors() as errors:
b1 = FakeBuilder(workernames=[], name='b1', builddir='dir', project=None)
b2 = FakeBuilder(workernames=[], name='b2', builddir='dir', project=None)
self.cfg.builders = [b1, b2]
self.cfg.check_builders()
self.assertConfigError(errors, "duplicate builder builddir 'dir'")
def test_check_builders(self):
with capture_config_errors() as errors:
wrk = mock.Mock()
wrk.workername = 'a'
self.cfg.workers = [wrk]
project = mock.Mock()
project.name = 'proj1'
self.cfg.projects = [project]
b1 = FakeBuilder(workernames=['a'], name='b1', builddir='dir1', project='proj1')
b2 = FakeBuilder(workernames=['a'], name='b2', builddir='dir2', project=None)
self.cfg.builders = [b1, b2]
self.cfg.check_builders()
self.assertNoConfigErrors(errors)
def test_check_duplicate_projects(self):
with capture_config_errors() as errors:
project1 = mock.Mock()
project1.name = 'proj1'
project2 = mock.Mock()
project2.name = 'proj1'
self.cfg.projects = [project1, project2]
self.cfg.check_projects()
self.assertConfigError(errors, "duplicate project name 'proj1'")
def test_check_ports_protocols_set(self):
with capture_config_errors() as errors:
self.cfg.protocols = {"pb": {"port": 10}}
self.cfg.check_ports()
self.assertNoConfigErrors(errors)
def test_check_ports_protocols_not_set_workers(self):
with capture_config_errors() as errors:
self.cfg.workers = [mock.Mock()]
self.cfg.check_ports()
self.assertConfigError(errors, "workers are configured, but c['protocols'] not")
def test_check_ports_protocols_port_duplication(self):
with capture_config_errors() as errors:
self.cfg.protocols = {"pb": {"port": 123}, "amp": {"port": 123}}
self.cfg.check_ports()
self.assertConfigError(errors, "Some of ports in c['protocols'] duplicated")
def test_check_machines_unknown_name(self):
with capture_config_errors() as errors:
self.cfg.workers = [FakeWorker(name='wa', machine_name='unk')]
self.cfg.machines = [FakeMachine(name='a')]
self.cfg.check_machines()
self.assertConfigError(errors, 'uses unknown machine')
def test_check_machines_duplicate_name(self):
with capture_config_errors() as errors:
self.cfg.machines = [FakeMachine(name='a'), FakeMachine(name='a')]
self.cfg.check_machines()
self.assertConfigError(errors, 'duplicate machine name')
class MasterConfig_old_worker_api(unittest.TestCase):
filename = "test.cfg"
def setUp(self):
self.cfg = config.master.MasterConfig()
def test_workers_new_api(self):
with assertNotProducesWarnings(DeprecatedApiWarning):
self.assertEqual(self.cfg.workers, [])
class FakeService(service.ReconfigurableServiceMixin, service.AsyncService):
succeed = True
call_index = 1
@defer.inlineCallbacks
def reconfigServiceWithBuildbotConfig(self, new_config):
self.called = FakeService.call_index
FakeService.call_index += 1
yield super().reconfigServiceWithBuildbotConfig(new_config)
if not self.succeed:
raise ValueError("oh noes")
class FakeMultiService(service.ReconfigurableServiceMixin, service.AsyncMultiService):
def reconfigServiceWithBuildbotConfig(self, new_config):
self.called = True
d = super().reconfigServiceWithBuildbotConfig(new_config)
return d
class ReconfigurableServiceMixin(unittest.TestCase):
@defer.inlineCallbacks
def test_service(self):
svc = FakeService()
yield svc.reconfigServiceWithBuildbotConfig(mock.Mock())
self.assertTrue(svc.called)
@defer.inlineCallbacks
def test_service_failure(self):
svc = FakeService()
svc.succeed = False
try:
yield svc.reconfigServiceWithBuildbotConfig(mock.Mock())
except ValueError:
pass
else:
self.fail("should have raised ValueError")
@defer.inlineCallbacks
def test_multiservice(self):
svc = FakeMultiService()
ch1 = FakeService()
yield ch1.setServiceParent(svc)
ch2 = FakeMultiService()
yield ch2.setServiceParent(svc)
ch3 = FakeService()
yield ch3.setServiceParent(ch2)
yield svc.reconfigServiceWithBuildbotConfig(mock.Mock())
self.assertTrue(svc.called)
self.assertTrue(ch1.called)
self.assertTrue(ch2.called)
self.assertTrue(ch3.called)
@defer.inlineCallbacks
def test_multiservice_priority(self):
parent = FakeMultiService()
svc128 = FakeService()
yield svc128.setServiceParent(parent)
services = [svc128]
for i in range(20, 1, -1):
svc = FakeService()
svc.reconfig_priority = i
yield svc.setServiceParent(parent)
services.append(svc)
yield parent.reconfigServiceWithBuildbotConfig(mock.Mock())
prio_order = [s.called for s in services]
called_order = sorted(prio_order)
self.assertEqual(prio_order, called_order)
@defer.inlineCallbacks
def test_multiservice_nested_failure(self):
svc = FakeMultiService()
ch1 = FakeService()
yield ch1.setServiceParent(svc)
ch1.succeed = False
try:
yield svc.reconfigServiceWithBuildbotConfig(mock.Mock())
except ValueError:
pass
else:
self.fail("should have raised ValueError")
| 51,657 | Python | .py | 1,102 | 37.07078 | 99 | 0.626881 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,428 | test_builder.py | buildbot_buildbot/master/buildbot/test/unit/config/test_builder.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.trial import unittest
from buildbot.config.builder import BuilderConfig
from buildbot.process import factory
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.warnings import assertNotProducesWarnings
from buildbot.warnings import DeprecatedApiWarning
class BuilderConfigTests(ConfigErrorsMixin, unittest.TestCase):
factory = factory.BuildFactory()
# utils
def assertAttributes(self, cfg, **expected):
got = {attr: getattr(cfg, attr) for attr, exp in expected.items()}
self.assertEqual(got, expected)
# tests
def test_no_name(self):
with self.assertRaisesConfigError("builder's name is required"):
BuilderConfig(factory=self.factory, workernames=['a'])
def test_reserved_name(self):
with self.assertRaisesConfigError("builder names must not start with an underscore: '_a'"):
BuilderConfig(name='_a', factory=self.factory, workernames=['a'])
def test_utf8_name(self):
with self.assertRaisesConfigError("builder names must be unicode or ASCII"):
BuilderConfig(name="\N{SNOWMAN}".encode(), factory=self.factory, workernames=['a'])
def test_no_factory(self):
with self.assertRaisesConfigError("builder 'a' has no factory"):
BuilderConfig(name='a', workernames=['a'])
def test_wrong_type_factory(self):
with self.assertRaisesConfigError("builder 'a's factory is not"):
BuilderConfig(factory=[], name='a', workernames=['a'])
def test_no_workernames(self):
with self.assertRaisesConfigError("builder 'a': at least one workername is required"):
BuilderConfig(name='a', factory=self.factory)
def test_bogus_workernames(self):
with self.assertRaisesConfigError("workernames must be a list or a string"):
BuilderConfig(name='a', workernames={1: 2}, factory=self.factory)
def test_bogus_workername(self):
with self.assertRaisesConfigError("workername must be a string"):
BuilderConfig(name='a', workername=1, factory=self.factory)
def test_tags_must_be_list(self):
with self.assertRaisesConfigError("tags must be a list"):
BuilderConfig(tags='abc', name='a', workernames=['a'], factory=self.factory)
def test_tags_must_be_list_of_str(self):
with self.assertRaisesConfigError("tags list contains something that is not a string"):
BuilderConfig(tags=['abc', 13], name='a', workernames=['a'], factory=self.factory)
def test_tags_no_tag_dupes(self):
with self.assertRaisesConfigError("builder 'a': tags list contains duplicate tags: abc"):
BuilderConfig(
tags=['abc', 'bca', 'abc'], name='a', workernames=['a'], factory=self.factory
)
def test_inv_nextWorker(self):
with self.assertRaisesConfigError("nextWorker must be a callable"):
BuilderConfig(nextWorker="foo", name="a", workernames=['a'], factory=self.factory)
def test_inv_nextBuild(self):
with self.assertRaisesConfigError("nextBuild must be a callable"):
BuilderConfig(nextBuild="foo", name="a", workernames=['a'], factory=self.factory)
def test_inv_canStartBuild(self):
with self.assertRaisesConfigError("canStartBuild must be a callable"):
BuilderConfig(canStartBuild="foo", name="a", workernames=['a'], factory=self.factory)
def test_inv_env(self):
with self.assertRaisesConfigError("builder's env must be a dictionary"):
BuilderConfig(env="foo", name="a", workernames=['a'], factory=self.factory)
def test_defaults(self):
cfg = BuilderConfig(name='a b c', workername='a', factory=self.factory)
self.assertIdentical(cfg.factory, self.factory)
self.assertAttributes(
cfg,
name='a b c',
workernames=['a'],
builddir='a_b_c',
workerbuilddir='a_b_c',
tags=[],
nextWorker=None,
locks=[],
env={},
properties={},
collapseRequests=None,
description=None,
)
def test_unicode_name(self):
cfg = BuilderConfig(name='a \N{SNOWMAN} c', workername='a', factory=self.factory)
self.assertIdentical(cfg.factory, self.factory)
self.assertAttributes(cfg, name='a \N{SNOWMAN} c')
def test_args(self):
cfg = BuilderConfig(
name='b',
workername='s1',
workernames='s2',
builddir='bd',
workerbuilddir='wbd',
factory=self.factory,
tags=['c'],
nextWorker=lambda: 'ns',
nextBuild=lambda: 'nb',
locks=['l'],
env={"x": 10},
properties={"y": 20},
collapseRequests='cr',
description='buzz',
)
self.assertIdentical(cfg.factory, self.factory)
self.assertAttributes(
cfg,
name='b',
workernames=['s2', 's1'],
builddir='bd',
workerbuilddir='wbd',
tags=['c'],
locks=['l'],
env={'x': 10},
properties={'y': 20},
collapseRequests='cr',
description='buzz',
)
def test_too_long_property(self):
with self.assertRaisesConfigError("exceeds maximum length of"):
BuilderConfig(
name="a", workernames=['a'], factory=self.factory, properties={'a' * 257: 'value'}
)
def test_too_long_default_property(self):
with self.assertRaisesConfigError("exceeds maximum length of"):
BuilderConfig(
name="a",
workernames=['a'],
factory=self.factory,
defaultProperties={'a' * 257: 'value'},
)
def test_description_wrong_format(self):
with self.assertRaisesConfigError("builder description format must be None"):
BuilderConfig(
name="a", workernames=['a'], factory=self.factory, description_format="unknown"
)
def test_getConfigDict(self):
ns = lambda: 'ns'
nb = lambda: 'nb'
cfg = BuilderConfig(
name='b',
workername='s1',
workernames='s2',
builddir='bd',
workerbuilddir='wbd',
factory=self.factory,
tags=['c'],
nextWorker=ns,
nextBuild=nb,
locks=['l'],
env={"x": 10},
properties={"y": 20},
collapseRequests='cr',
description='buzz',
)
self.assertEqual(
cfg.getConfigDict(),
{
'builddir': 'bd',
'tags': ['c'],
'description': 'buzz',
'env': {'x': 10},
'factory': self.factory,
'locks': ['l'],
'collapseRequests': 'cr',
'name': 'b',
'nextBuild': nb,
'nextWorker': ns,
'properties': {'y': 20},
'workerbuilddir': 'wbd',
'workernames': ['s2', 's1'],
},
)
def test_getConfigDict_collapseRequests(self):
for cr in (False, lambda a, b, c: False):
cfg = BuilderConfig(
name='b', collapseRequests=cr, factory=self.factory, workername='s1'
)
self.assertEqual(
cfg.getConfigDict(),
{
'builddir': 'b',
'collapseRequests': cr,
'name': 'b',
'workerbuilddir': 'b',
'factory': self.factory,
'workernames': ['s1'],
},
)
def test_init_workername_keyword(self):
cfg = BuilderConfig(name='a b c', workername='a', factory=self.factory)
self.assertEqual(cfg.workernames, ['a'])
def test_init_workername_positional(self):
with assertNotProducesWarnings(DeprecatedApiWarning):
cfg = BuilderConfig('a b c', 'a', factory=self.factory)
self.assertEqual(cfg.workernames, ['a'])
def test_init_workernames_keyword(self):
cfg = BuilderConfig(name='a b c', workernames=['a'], factory=self.factory)
self.assertEqual(cfg.workernames, ['a'])
def test_init_workernames_positional(self):
with assertNotProducesWarnings(DeprecatedApiWarning):
cfg = BuilderConfig('a b c', None, ['a'], factory=self.factory)
self.assertEqual(cfg.workernames, ['a'])
def test_init_workerbuilddir_keyword(self):
cfg = BuilderConfig(
name='a b c', workername='a', factory=self.factory, workerbuilddir="dir"
)
self.assertEqual(cfg.workerbuilddir, 'dir')
def test_init_workerbuilddir_positional(self):
with assertNotProducesWarnings(DeprecatedApiWarning):
cfg = BuilderConfig('a b c', 'a', None, None, 'dir', factory=self.factory)
self.assertEqual(cfg.workerbuilddir, 'dir')
def test_init_next_worker_keyword(self):
f = lambda: None
cfg = BuilderConfig(name='a b c', workername='a', factory=self.factory, nextWorker=f)
self.assertEqual(cfg.nextWorker, f)
| 10,053 | Python | .py | 224 | 34.366071 | 99 | 0.603924 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,429 | test_errors.py | buildbot_buildbot/master/buildbot/test/unit/config/test_errors.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.trial import unittest
from buildbot.config.errors import ConfigErrors
from buildbot.config.errors import capture_config_errors
from buildbot.config.errors import error
class ConfigErrorsTest(unittest.TestCase):
def test_constr(self):
ex = ConfigErrors(['a', 'b'])
self.assertEqual(ex.errors, ['a', 'b'])
def test_addError(self):
ex = ConfigErrors(['a'])
ex.addError('c')
self.assertEqual(ex.errors, ['a', 'c'])
def test_nonempty(self):
empty = ConfigErrors()
full = ConfigErrors(['a'])
self.assertTrue(not empty)
self.assertFalse(not full)
def test_error_raises(self):
with self.assertRaises(ConfigErrors) as e:
error("message")
self.assertEqual(e.exception.errors, ["message"])
def test_error_no_raise(self):
with capture_config_errors() as errors:
error("message")
self.assertEqual(errors.errors, ["message"])
def test_str(self):
ex = ConfigErrors()
self.assertEqual(str(ex), "")
ex = ConfigErrors(["a"])
self.assertEqual(str(ex), "a")
ex = ConfigErrors(["a", "b"])
self.assertEqual(str(ex), "a\nb")
ex = ConfigErrors(["a"])
ex.addError('c')
self.assertEqual(str(ex), "a\nc")
| 2,033 | Python | .py | 49 | 35.653061 | 79 | 0.680873 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,430 | test_checks.py | buildbot_buildbot/master/buildbot/test/unit/config/test_checks.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.trial import unittest
from buildbot.config.checks import check_param_length
from buildbot.config.checks import check_param_str
from buildbot.config.checks import check_param_str_none
from buildbot.process.properties import Interpolate
from buildbot.test.util import config
class TestCheckParamLength(unittest.TestCase, config.ConfigErrorsMixin):
def test_short_string(self):
check_param_length('1234567890', 'Step name', 10)
def test_long_string(self):
with self.assertRaisesConfigError("exceeds maximum length of 10"):
check_param_length('12345678901', 'Step name', 10)
def test_short_interpolate(self):
check_param_length(Interpolate('123456%(prop:xy)s7890'), 'Step name', 10)
def test_short_interpolate_args(self):
check_param_length(Interpolate('123456%s7890', 'arg'), 'Step name', 10)
def test_short_interpolate_kwargs(self):
check_param_length(Interpolate('123456%(prop:xy)s7890', kw='arg'), 'Step name', 10)
def test_long_interpolate(self):
with self.assertRaisesConfigError("exceeds maximum length of 10"):
check_param_length(Interpolate('123456%(prop:xy)s78901'), 'Step name', 10)
class TestCheckParamType(unittest.TestCase, config.ConfigErrorsMixin):
def test_str(self):
check_param_str('abc', self.__class__, 'param')
def test_str_wrong(self):
msg = "TestCheckParamType argument param must be an instance of str"
with self.assertRaisesConfigError(msg):
check_param_str(1, self.__class__, 'param')
def test_str_none(self):
check_param_str_none('abc', self.__class__, 'param')
check_param_str_none(None, self.__class__, 'param')
def test_str_none_wrong(self):
msg = "TestCheckParamType argument param must be an instance of str or None"
with self.assertRaisesConfigError(msg):
check_param_str_none(1, self.__class__, 'param')
| 2,659 | Python | .py | 49 | 49.061224 | 91 | 0.729584 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,431 | test_users_manager.py | buildbot_buildbot/master/buildbot/test/unit/process/test_users_manager.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.config.master import MasterConfig
from buildbot.process.users import manager
from buildbot.util import service
class FakeUserManager(service.AsyncMultiService):
pass
class TestUserManager(unittest.TestCase):
def setUp(self):
self.master = mock.Mock()
self.umm = manager.UserManagerManager(self.master)
self.umm.startService()
self.config = MasterConfig()
def tearDown(self):
self.umm.stopService()
@defer.inlineCallbacks
def test_reconfigServiceWithBuildbotConfig(self):
# add a user manager
um1 = FakeUserManager()
self.config.user_managers = [um1]
yield self.umm.reconfigServiceWithBuildbotConfig(self.config)
self.assertTrue(um1.running)
self.assertIdentical(um1.master, self.master)
# and back to nothing
self.config.user_managers = []
yield self.umm.reconfigServiceWithBuildbotConfig(self.config)
self.assertIdentical(um1.master, None)
| 1,810 | Python | .py | 42 | 38.428571 | 79 | 0.757697 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,432 | test_workerforbuilder.py | buildbot_buildbot/master/buildbot/test/unit/process/test_workerforbuilder.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.trial.unittest import TestCase
from buildbot.process.builder import Builder
from buildbot.process.workerforbuilder import AbstractWorkerForBuilder
from buildbot.worker.base import AbstractWorker
class TestAbstractWorkerForBuilder(TestCase):
"""
Tests for ``AbstractWorkerForBuilder``.
"""
def test_buildStarted_called(self):
"""
If the worker associated to worker builder has a ``buildStarted`` method,
calling ``buildStarted`` on the worker builder calls the method on the
worker with the workerforbuilder as an argument.
"""
class ConcreteWorker(AbstractWorker):
_buildStartedCalls = []
def buildStarted(self, workerforbuilder):
self._buildStartedCalls.append(workerforbuilder)
fake_builder = Builder("fake_builder")
worker = ConcreteWorker("worker", "pass")
workerforbuilder = AbstractWorkerForBuilder(fake_builder)
# FIXME: This should call attached, instead of setting the attribute
# directly
workerforbuilder.worker = worker
workerforbuilder.buildStarted()
self.assertEqual(ConcreteWorker._buildStartedCalls, [workerforbuilder])
def test_buildStarted_missing(self):
"""
If the worker associated to worker builder doesn't not have a
``buildStarted`` method, calling ``buildStarted`` on the worker builder
doesn't raise an exception.
"""
class ConcreteWorker(AbstractWorker):
pass
fake_builder = Builder("fake_builder")
worker = ConcreteWorker("worker", "pass")
workerforbuilder = AbstractWorkerForBuilder(fake_builder)
# FIXME: This should call attached, instead of setting the attribute
# directly
workerforbuilder.worker = worker
# The following shouldn't raise an exception.
workerforbuilder.buildStarted()
| 2,643 | Python | .py | 56 | 40.678571 | 81 | 0.724165 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,433 | test_debug.py | buildbot_buildbot/master/buildbot/test/unit/process/test_debug.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.config.master import MasterConfig
from buildbot.process import debug
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.util import service
class FakeManhole(service.AsyncService):
pass
class TestDebugServices(TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = mock.Mock(name='master')
self.config = MasterConfig()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_reconfigService_manhole(self):
master = yield fakemaster.make_master(self)
ds = debug.DebugServices()
yield 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)
| 2,534 | Python | .py | 57 | 38.929825 | 79 | 0.750305 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,434 | test_factory.py | buildbot_buildbot/master/buildbot/test/unit/process/test_factory.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from random import choice
from string import ascii_uppercase
from twisted.trial import unittest
from buildbot.process.buildstep import BuildStep
from buildbot.process.buildstep import _BuildStepFactory
from buildbot.process.factory import BuildFactory
from buildbot.process.factory import GNUAutoconf
from buildbot.process.factory import s
from buildbot.steps.shell import Configure
class TestBuildFactory(unittest.TestCase):
def setUp(self):
self.factory = BuildFactory()
def test_init(self):
step = BuildStep()
self.factory = BuildFactory([step])
self.assertEqual(self.factory.steps, [_BuildStepFactory(BuildStep)])
def test_addStep(self):
# create a string random string that will probably not collide
# with what is already in the factory
string = ''.join(choice(ascii_uppercase) for x in range(6))
length = len(self.factory.steps)
step = BuildStep(name=string)
self.factory.addStep(step)
# check if the number of nodes grew by one
self.assertTrue(length + 1, len(self.factory.steps))
# check if the 'right' node added in the factory
self.assertEqual(self.factory.steps[-1], _BuildStepFactory(BuildStep, name=string))
def test_s(self):
"""
L{s} is deprecated, but pass keyword arguments to the first argument,
to construct a step.
"""
stepFactory = s(BuildStep, name='test')
self.assertEqual(stepFactory, _BuildStepFactory(BuildStep, name='test'))
warnings = self.flushWarnings([self.test_s])
self.assertEqual(len(warnings), 1)
self.assertEqual(warnings[0]['category'], DeprecationWarning)
def test_addStep_notAStep(self):
# This fails because object isn't adaptable to IBuildStepFactory
with self.assertRaises(TypeError):
self.factory.addStep(object())
def test_addStep_ArgumentsInTheWrongPlace(self):
with self.assertRaises(TypeError):
self.factory.addStep(BuildStep(), name="name")
# this also raises a deprecation error, which we don't care about (see
# test_s)
self.flushWarnings()
def test_addSteps(self):
self.factory.addSteps([BuildStep(), BuildStep()])
self.assertEqual(
self.factory.steps[-2:], [_BuildStepFactory(BuildStep), _BuildStepFactory(BuildStep)]
)
class TestGNUAutoconf(TestBuildFactory):
def setUp(self):
self.factory = GNUAutoconf(source=BuildStep())
def test_init(self):
# actual initialization is already done by setUp
configurePresent = False
compilePresent = False
checkPresent = False
distcheckPresent = False
for step in self.factory.steps:
if isinstance(step.buildStep(), Configure):
configurePresent = True
# the following checks are rather hairy and should be
# rewritten less implementation dependent.
try:
if step.buildStep().command == ['make', 'all']:
compilePresent = True
if step.buildStep().command == ['make', 'check']:
checkPresent = True
if step.buildStep().command == ['make', 'distcheck']:
distcheckPresent = True
except (AttributeError, KeyError):
pass
self.assertTrue(configurePresent)
self.assertTrue(compilePresent)
self.assertTrue(checkPresent)
self.assertTrue(distcheckPresent)
def test_init_none(self):
"""Default steps can be uninitialized by setting None"""
self.factory = GNUAutoconf(source=BuildStep(), compile=None, test=None, distcheck=None)
for step in self.factory.steps:
try:
cmd = step.buildStep().command
self.assertNotIn(
cmd,
[['make', 'all'], ['make', 'check'], ['make', 'distcheck']],
f"Build step {cmd} should not be present.",
)
except (AttributeError, KeyError):
pass
def test_init_reconf(self):
# test reconf = True
self.factory = GNUAutoconf(source=BuildStep(), reconf=True)
self.test_init()
reconfPresent = False
selfreconfPresent = False
for step in self.factory.steps:
try:
if step.buildStep().command[0] == 'autoreconf':
reconfPresent = True
except (AttributeError, KeyError):
pass
self.assertTrue(reconfPresent)
# test setting your own reconfiguration step
self.factory = GNUAutoconf(source=BuildStep(), reconf=['notsoautoreconf'])
self.test_init()
for step in self.factory.steps:
try:
if step.buildStep().command == ['notsoautoreconf']:
selfreconfPresent = True
except (AttributeError, KeyError):
pass
self.assertTrue(selfreconfPresent)
| 5,789 | Python | .py | 129 | 35.604651 | 97 | 0.651588 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,435 | test_results.py | buildbot_buildbot/master/buildbot/test/unit/process/test_results.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.python import log
from twisted.trial import unittest
from buildbot.process import results
class TestResults(unittest.TestCase):
def test_Results(self):
for r in results.Results:
i = getattr(results, r.upper())
self.assertEqual(results.Results[i], r)
def test_worst_status(self):
self.assertEqual(results.WARNINGS, results.worst_status(results.SUCCESS, results.WARNINGS))
self.assertEqual(
results.CANCELLED, results.worst_status(results.SKIPPED, results.CANCELLED)
)
def test_sort_worst_status(self):
res = list(range(len(results.Results)))
res.sort(key=lambda a: a if a != results.SKIPPED else -1)
self.assertEqual(
res,
[
results.SKIPPED,
results.SUCCESS,
results.WARNINGS,
results.FAILURE,
results.EXCEPTION,
results.RETRY,
results.CANCELLED,
],
)
def do_test_carc(
self,
result,
previousResult,
newResult,
terminate,
haltOnFailure=None,
flunkOnWarnings=None,
flunkOnFailure=None,
warnOnWarnings=None,
warnOnFailure=None,
):
if haltOnFailure is None:
haltOnFailure = [True, False]
if flunkOnWarnings is None:
flunkOnWarnings = [True, False]
if flunkOnFailure is None:
flunkOnFailure = [True, False]
if warnOnWarnings is None:
warnOnWarnings = [True, False]
if warnOnFailure is None:
warnOnFailure = [True, False]
for hof in haltOnFailure:
for fow in flunkOnWarnings:
for fof in flunkOnFailure:
for wow in warnOnWarnings:
for wof in warnOnFailure:
self.haltOnFailure = hof
self.flunkOnWarnings = fow
self.flunkOnFailure = fof
self.warnOnWarnings = wow
self.warnOnFailure = wof
nr, term = results.computeResultAndTermination(
self, result, previousResult
)
log.msg(
f"res={results.Results[result]!r} "
f"prevRes={results.Results[previousResult]!r} "
f"hof={hof!r} fow={fow!r} fof={fof!r} "
f"wow={wow!r} wof={wof!r} => "
f"{results.Results[nr]!r} {term!r}"
)
self.assertEqual(
(nr, term), (newResult, terminate), "see test.log for details"
)
def test_carc_success_after_success(self):
self.do_test_carc(results.SUCCESS, results.SUCCESS, results.SUCCESS, False)
def test_carc_success_after_warnings(self):
self.do_test_carc(results.SUCCESS, results.WARNINGS, results.WARNINGS, False)
def test_carc_success_after_failure(self):
self.do_test_carc(results.SUCCESS, results.FAILURE, results.FAILURE, False)
def test_carc_warnings_after_success(self):
self.do_test_carc(
results.WARNINGS,
results.SUCCESS,
results.WARNINGS,
False,
flunkOnWarnings=[False],
warnOnWarnings=[True],
)
self.do_test_carc(
results.WARNINGS,
results.SUCCESS,
results.SUCCESS,
False,
flunkOnWarnings=[False],
warnOnWarnings=[False],
)
self.do_test_carc(
results.WARNINGS,
results.SUCCESS,
results.FAILURE,
False,
flunkOnWarnings=[True],
warnOnWarnings=[True],
)
self.do_test_carc(
results.WARNINGS,
results.SUCCESS,
results.FAILURE,
False,
flunkOnWarnings=[True],
warnOnWarnings=[False],
)
def test_carc_warnings_after_warnings(self):
self.do_test_carc(
results.WARNINGS, results.WARNINGS, results.WARNINGS, False, flunkOnWarnings=[False]
)
self.do_test_carc(
results.WARNINGS, results.WARNINGS, results.FAILURE, False, flunkOnWarnings=[True]
)
def test_carc_warnings_after_failure(self):
self.do_test_carc(
results.WARNINGS, results.FAILURE, results.FAILURE, False, flunkOnWarnings=[False]
)
self.do_test_carc(
results.WARNINGS, results.FAILURE, results.FAILURE, False, flunkOnWarnings=[True]
)
def test_carc_failure_after_success(self):
for hof in False, True:
self.do_test_carc(
results.FAILURE,
results.SUCCESS,
results.FAILURE,
hof,
haltOnFailure=[hof],
flunkOnFailure=[True],
warnOnFailure=[False],
)
self.do_test_carc(
results.FAILURE,
results.SUCCESS,
results.FAILURE,
hof,
haltOnFailure=[hof],
flunkOnFailure=[True],
warnOnFailure=[True],
)
self.do_test_carc(
results.FAILURE,
results.SUCCESS,
results.SUCCESS,
hof,
haltOnFailure=[hof],
flunkOnFailure=[False],
warnOnFailure=[False],
)
self.do_test_carc(
results.FAILURE,
results.SUCCESS,
results.WARNINGS,
hof,
haltOnFailure=[hof],
flunkOnFailure=[False],
warnOnFailure=[True],
)
def test_carc_failure_after_warnings(self):
for hof in False, True:
self.do_test_carc(
results.FAILURE,
results.WARNINGS,
results.FAILURE,
hof,
haltOnFailure=[hof],
flunkOnFailure=[True],
)
self.do_test_carc(
results.FAILURE,
results.WARNINGS,
results.WARNINGS,
hof,
haltOnFailure=[hof],
flunkOnFailure=[False],
)
def test_carc_failure_after_failure(self):
for hof in False, True:
self.do_test_carc(
results.FAILURE, results.FAILURE, results.FAILURE, hof, haltOnFailure=[hof]
)
def test_carc_exception(self):
for prev in results.FAILURE, results.WARNINGS, results.SUCCESS:
self.do_test_carc(results.EXCEPTION, prev, results.EXCEPTION, True)
def test_carc_retry(self):
for prev in results.FAILURE, results.WARNINGS, results.SUCCESS:
self.do_test_carc(results.RETRY, prev, results.RETRY, True)
def test_carc_cancelled(self):
for prev in results.FAILURE, results.WARNINGS, results.SUCCESS:
self.do_test_carc(results.CANCELLED, prev, results.CANCELLED, True)
def test_carc_skipped(self):
for prev in results.FAILURE, results.WARNINGS, results.SUCCESS:
self.do_test_carc(results.SKIPPED, prev, prev, False)
| 8,278 | Python | .py | 213 | 25.901408 | 99 | 0.554257 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,436 | test_metrics.py | buildbot_buildbot/master/buildbot/test/unit/process/test_metrics.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import gc
import sys
from twisted.internet import defer
from twisted.internet import task
from twisted.trial import unittest
from buildbot.process import metrics
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
class TestMetricBase(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.observer = metrics.MetricLogObserver()
self.observer.parent = self.master = yield fakemaster.make_master(self)
self.master.config.metrics = {"log_interval": 0, "periodic_interval": 0}
self.observer._reactor = self.reactor
self.observer.startService()
self.observer.reconfigServiceWithBuildbotConfig(self.master.config)
@defer.inlineCallbacks
def tearDown(self):
if self.observer.running:
yield self.observer.stopService()
yield self.tear_down_test_reactor()
class TestMetricCountEvent(TestMetricBase):
def testIncrement(self):
metrics.MetricCountEvent.log('num_widgets', 1)
report = self.observer.asDict()
self.assertEqual(report['counters']['num_widgets'], 1)
metrics.MetricCountEvent.log('num_widgets', 1)
report = self.observer.asDict()
self.assertEqual(report['counters']['num_widgets'], 2)
def testDecrement(self):
metrics.MetricCountEvent.log('num_widgets', 1)
report = self.observer.asDict()
self.assertEqual(report['counters']['num_widgets'], 1)
metrics.MetricCountEvent.log('num_widgets', -1)
report = self.observer.asDict()
self.assertEqual(report['counters']['num_widgets'], 0)
def testAbsolute(self):
metrics.MetricCountEvent.log('num_widgets', 10, absolute=True)
report = self.observer.asDict()
self.assertEqual(report['counters']['num_widgets'], 10)
def testCountMethod(self):
@metrics.countMethod('foo_called')
def foo():
return "foo!"
for _ in range(10):
foo()
report = self.observer.asDict()
self.assertEqual(report['counters']['foo_called'], 10)
class TestMetricTimeEvent(TestMetricBase):
def testManualEvent(self):
metrics.MetricTimeEvent.log('foo_time', 0.001)
report = self.observer.asDict()
self.assertEqual(report['timers']['foo_time'], 0.001)
def testTimer(self):
clock = task.Clock()
t = metrics.Timer('foo_time')
t._reactor = clock
t.start()
clock.advance(5)
t.stop()
report = self.observer.asDict()
self.assertEqual(report['timers']['foo_time'], 5)
def testStartStopDecorators(self):
clock = task.Clock()
t = metrics.Timer('foo_time')
t._reactor = clock
@t.startTimer
def foo():
clock.advance(5)
return "foo!"
@t.stopTimer
def bar():
clock.advance(5)
return "bar!"
foo()
bar()
report = self.observer.asDict()
self.assertEqual(report['timers']['foo_time'], 10)
def testTimeMethod(self):
clock = task.Clock()
@metrics.timeMethod('foo_time', _reactor=clock)
def foo():
clock.advance(5)
return "foo!"
foo()
report = self.observer.asDict()
self.assertEqual(report['timers']['foo_time'], 5)
def testAverages(self):
data = list(range(10))
for i in data:
metrics.MetricTimeEvent.log('foo_time', i)
report = self.observer.asDict()
self.assertEqual(report['timers']['foo_time'], sum(data) / float(len(data)))
class TestPeriodicChecks(TestMetricBase):
def testPeriodicCheck(self):
# fake out that there's no garbage (since we can't rely on Python
# not having any garbage while running tests)
self.patch(gc, 'garbage', [])
clock = task.Clock()
metrics.periodicCheck(_reactor=clock)
clock.pump([0.1, 0.1, 0.1])
# We should have 0 reactor delay since we're using a fake clock
report = self.observer.asDict()
self.assertEqual(report['timers']['reactorDelay'], 0)
self.assertEqual(report['counters']['gc.garbage'], 0)
self.assertEqual(report['alarms']['gc.garbage'][0], 'OK')
def testUncollectable(self):
# make some fake garbage
self.patch(gc, 'garbage', [1, 2])
clock = task.Clock()
metrics.periodicCheck(_reactor=clock)
clock.pump([0.1, 0.1, 0.1])
# We should have 0 reactor delay since we're using a fake clock
report = self.observer.asDict()
self.assertEqual(report['timers']['reactorDelay'], 0)
self.assertEqual(report['counters']['gc.garbage'], 2)
self.assertEqual(report['alarms']['gc.garbage'][0], 'WARN')
def testGetRSS(self):
self.assertTrue(metrics._get_rss() > 0)
if sys.platform != 'linux':
testGetRSS.skip = "only available on linux platforms"
class TestReconfig(TestMetricBase):
def testReconfig(self):
observer = self.observer
new_config = self.master.config
# starts up without running tasks
self.assertEqual(observer.log_task, None)
self.assertEqual(observer.periodic_task, None)
# enable log_interval
new_config.metrics = {"log_interval": 10, "periodic_interval": 0}
observer.reconfigServiceWithBuildbotConfig(new_config)
self.assertTrue(observer.log_task)
self.assertEqual(observer.periodic_task, None)
# disable that and enable periodic_interval
new_config.metrics = {"periodic_interval": 10, "log_interval": 0}
observer.reconfigServiceWithBuildbotConfig(new_config)
self.assertTrue(observer.periodic_task)
self.assertEqual(observer.log_task, None)
# Make the periodic check run
self.reactor.pump([0.1])
# disable the whole listener
new_config.metrics = None
observer.reconfigServiceWithBuildbotConfig(new_config)
self.assertFalse(observer.enabled)
self.assertEqual(observer.log_task, None)
self.assertEqual(observer.periodic_task, None)
# disable both
new_config.metrics = {"periodic_interval": 0, "log_interval": 0}
observer.reconfigServiceWithBuildbotConfig(new_config)
self.assertEqual(observer.log_task, None)
self.assertEqual(observer.periodic_task, None)
# enable both
new_config.metrics = {"periodic_interval": 10, "log_interval": 10}
observer.reconfigServiceWithBuildbotConfig(new_config)
self.assertTrue(observer.log_task)
self.assertTrue(observer.periodic_task)
# (service will be stopped by tearDown)
class _LogObserver:
def __init__(self):
self.events = []
def gotEvent(self, event):
self.events.append(event)
class TestReports(unittest.TestCase):
def testMetricCountReport(self):
handler = metrics.MetricCountHandler(None)
handler.handle({}, metrics.MetricCountEvent('num_foo', 1))
self.assertEqual("Counter num_foo: 1", handler.report())
self.assertEqual({"counters": {"num_foo": 1}}, handler.asDict())
def testMetricTimeReport(self):
handler = metrics.MetricTimeHandler(None)
handler.handle({}, metrics.MetricTimeEvent('time_foo', 1))
self.assertEqual("Timer time_foo: 1", handler.report())
self.assertEqual({"timers": {"time_foo": 1}}, handler.asDict())
def testMetricAlarmReport(self):
handler = metrics.MetricAlarmHandler(None)
handler.handle(
{}, metrics.MetricAlarmEvent('alarm_foo', msg='Uh oh', level=metrics.ALARM_WARN)
)
self.assertEqual("WARN alarm_foo: Uh oh", handler.report())
self.assertEqual({"alarms": {"alarm_foo": ("WARN", "Uh oh")}}, handler.asDict())
| 8,675 | Python | .py | 196 | 36.403061 | 92 | 0.66544 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,437 | test_log.py | buildbot_buildbot/master/buildbot/test/unit/process/test_log.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.internet import reactor
from twisted.trial import unittest
from buildbot.process import log
from buildbot.test.fake import fakemaster
from buildbot.test.fake import logfile as fakelogfile
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util import interfaces
class Tests(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def makeLog(self, type, logEncoding='utf-8'):
logid = yield self.master.data.updates.addLog(stepid=27, name='testlog', type=str(type))
return log.Log.new(self.master, 'testlog', type, logid, logEncoding)
@defer.inlineCallbacks
def test_creation(self):
for type in 'ths':
yield self.makeLog(type)
def test_logDecodeFunctionFromConfig(self):
otilde = '\u00f5'
otilde_utf8 = otilde.encode('utf-8')
otilde_latin1 = otilde.encode('latin1')
invalid_utf8 = b'\xff'
replacement = '\ufffd'
f = log.Log._decoderFromString('latin-1')
self.assertEqual(f(otilde_latin1), otilde)
f = log.Log._decoderFromString('utf-8')
self.assertEqual(f(otilde_utf8), otilde)
self.assertEqual(f(invalid_utf8), replacement)
f = log.Log._decoderFromString(lambda s: str(s[::-1]))
self.assertEqual(f('abc'), 'cba')
@defer.inlineCallbacks
def test_updates_plain(self):
_log = yield self.makeLog('t')
_log.addContent('hello\n')
_log.addContent('hello ')
_log.addContent('cruel ')
_log.addContent('world\nthis is a second line') # unfinished
yield _log.finish()
self.assertEqual(
self.master.data.updates.logs[_log.logid],
{
'content': ['hello\n', 'hello cruel world\n', 'this is a second line\n'],
'finished': True,
'type': 't',
'name': 'testlog',
},
)
@defer.inlineCallbacks
def test_updates_different_encoding(self):
_log = yield self.makeLog('t', logEncoding='latin-1')
# 0xa2 is latin-1 encoding for CENT SIGN
_log.addContent('$ and \xa2\n')
yield _log.finish()
self.assertEqual(
self.master.data.updates.logs[_log.logid]['content'], ['$ and \N{CENT SIGN}\n']
)
@defer.inlineCallbacks
def test_updates_unicode_input(self):
_log = yield self.makeLog('t', logEncoding='something-invalid')
_log.addContent('\N{SNOWMAN}\n')
yield _log.finish()
self.assertEqual(self.master.data.updates.logs[_log.logid]['content'], ['\N{SNOWMAN}\n'])
@defer.inlineCallbacks
def test_subscription_plain(self):
_log = yield self.makeLog('t')
calls = []
_log.subscribe(lambda stream, content: calls.append((stream, content)))
self.assertEqual(calls, [])
yield _log.addContent('hello\n')
self.assertEqual(calls, [(None, 'hello\n')])
calls = []
yield _log.addContent('hello ')
self.assertEqual(calls, [])
yield _log.addContent('cruel ')
self.assertEqual(calls, [])
yield _log.addContent('world\nthis is a second line\n')
self.assertEqual(calls, [(None, 'hello cruel world\nthis is a second line\n')])
calls = []
yield _log.finish()
self.assertEqual(calls, [(None, None)])
@defer.inlineCallbacks
def test_subscription_unsubscribe(self):
_log = yield self.makeLog('t')
sub_fn = mock.Mock()
sub = _log.subscribe(sub_fn)
sub.unsubscribe()
yield _log.finish()
sub_fn.assert_not_called()
@defer.inlineCallbacks
def test_subscription_stream(self):
_log = yield self.makeLog('s')
calls = []
_log.subscribe(lambda stream, content: calls.append((stream, content)))
self.assertEqual(calls, [])
yield _log.addStdout('hello\n')
self.assertEqual(calls, [('o', 'hello\n')])
calls = []
yield _log.addStdout('hello ')
self.assertEqual(calls, [])
yield _log.addStdout('cruel ')
self.assertEqual(calls, [])
yield _log.addStderr('!!\n')
self.assertEqual(calls, [('e', '!!\n')])
calls = []
yield _log.addHeader('**\n')
self.assertEqual(calls, [('h', '**\n')])
calls = []
yield _log.addStdout('world\nthis is a second line') # unfinished
self.assertEqual(calls, [('o', 'hello cruel world\n')])
calls = []
yield _log.finish()
self.assertEqual(calls, [('o', 'this is a second line\n'), (None, None)])
@defer.inlineCallbacks
def test_updates_stream(self):
_log = yield self.makeLog('s')
_log.addStdout('hello\n')
_log.addStdout('hello ')
_log.addStderr('oh noes!\n')
_log.addStdout('cruel world\n')
_log.addStderr('bad things!') # unfinished
yield _log.finish()
self.assertEqual(
self.master.data.updates.logs[_log.logid],
{
'content': ['ohello\n', 'eoh noes!\n', 'ohello cruel world\n', 'ebad things!\n'],
'finished': True,
'name': 'testlog',
'type': 's',
},
)
@defer.inlineCallbacks
def test_unyielded_finish(self):
_log = yield self.makeLog('s')
_log.finish()
with self.assertRaises(AssertionError):
yield _log.finish()
@defer.inlineCallbacks
def test_isFinished(self):
_log = yield self.makeLog('s')
self.assertFalse(_log.isFinished())
yield _log.finish()
self.assertTrue(_log.isFinished())
@defer.inlineCallbacks
def test_waitUntilFinished(self):
_log = yield self.makeLog('s')
d = _log.waitUntilFinished()
self.assertFalse(d.called)
yield _log.finish()
self.assertTrue(d.called)
class InterfaceTests(interfaces.InterfaceTests):
# for compatibility between old-style and new-style steps, both
# buildbot.status.logfile.LogFile and buildbot.process.log.StreamLog must
# meet this interface, at least until support for old-style steps is
# removed.
# ILogFile
def test_signature_addStdout(self):
@self.assertArgSpecMatches(self.log.addStdout)
def addStdout(self, text):
pass
def test_signature_addStderr(self):
@self.assertArgSpecMatches(self.log.addStderr)
def addStderr(self, text):
pass
def test_signature_addHeader(self):
@self.assertArgSpecMatches(self.log.addHeader)
def addHeader(self, text):
pass
def test_signature_finish(self):
@self.assertArgSpecMatches(self.log.finish)
def finish(self):
pass
# IStatusLog
def test_signature_getName(self):
@self.assertArgSpecMatches(self.log.getName)
def getName(self):
pass
def test_getName(self):
self.assertEqual(self.log.getName(), 'stdio')
def test_signature_isFinished(self):
@self.assertArgSpecMatches(self.log.isFinished)
def isFinished(self):
pass
def test_signature_waitUntilFinished(self):
@self.assertArgSpecMatches(self.log.waitUntilFinished)
def waitUntilFinished(self):
pass
def test_signature_subscribe(self):
@self.assertArgSpecMatches(self.log.subscribe)
def subscribe(self, callback):
pass
def test_signature_unsubscribe(self):
# method has been removed
self.assertFalse(hasattr(self.log, 'unsubscribe'))
def test_signature_getStep_removed(self):
self.assertFalse(hasattr(self.log, 'getStep'))
def test_signature_subscribeConsumer_removed(self):
self.assertFalse(hasattr(self.log, 'subscribeConsumer'))
def test_signature_hasContents_removed(self):
self.assertFalse(hasattr(self.log, 'hasContents'))
def test_signature_getText_removed(self):
self.assertFalse(hasattr(self.log, 'getText'))
def test_signature_readlines_removed(self):
self.assertFalse(hasattr(self.log, 'readlines'))
def test_signature_getTextWithHeaders_removed(self):
self.assertFalse(hasattr(self.log, 'getTextWithHeaders'))
def test_signature_getChunks_removed(self):
self.assertFalse(hasattr(self.log, 'getChunks'))
class TestProcessItfc(unittest.TestCase, InterfaceTests):
def setUp(self):
self.log = log.StreamLog(mock.Mock(name='master'), 'stdio', 's', 101, str)
class TestFakeLogFile(unittest.TestCase, InterfaceTests):
def setUp(self):
self.log = fakelogfile.FakeLogFile('stdio')
class TestErrorRaised(unittest.TestCase):
def instrumentTestedLoggerForError(self, testedLog):
def addRawLines(msg):
d = defer.Deferred()
def raiseError(_):
d.errback(RuntimeError('DB has gone away'))
reactor.callLater(10 ** (-6), raiseError, None)
return d
self.patch(testedLog, 'addRawLines', addRawLines)
return testedLog
@defer.inlineCallbacks
def testErrorOnStreamLog(self):
tested_log = self.instrumentTestedLoggerForError(
log.StreamLog(mock.Mock(name='master'), 'stdio', 's', 101, str)
)
correct_error_raised = False
try:
yield tested_log.addStdout('msg\n')
except Exception as e:
correct_error_raised = 'DB has gone away' in str(e)
self.assertTrue(correct_error_raised)
@defer.inlineCallbacks
def testErrorOnPlainLog(self):
tested_log = self.instrumentTestedLoggerForError(
log.PlainLog(mock.Mock(name='master'), 'stdio', 's', 101, str)
)
correct_error_raised = False
try:
yield tested_log.addContent('msg\n')
except Exception as e:
correct_error_raised = 'DB has gone away' in str(e)
self.assertTrue(correct_error_raised)
@defer.inlineCallbacks
def testErrorOnPlainLogFlush(self):
tested_log = self.instrumentTestedLoggerForError(
log.PlainLog(mock.Mock(name='master'), 'stdio', 's', 101, str)
)
correct_error_raised = False
try:
yield tested_log.addContent('msg')
yield tested_log.finish()
except Exception as e:
correct_error_raised = 'DB has gone away' in str(e)
self.assertTrue(correct_error_raised)
| 11,551 | Python | .py | 279 | 33.125448 | 97 | 0.64301 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,438 | test_build.py | buildbot_buildbot/master/buildbot/test/unit/process/test_build.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import operator
import posixpath
from unittest.mock import Mock
from unittest.mock import call
from twisted.internet import defer
from twisted.trial import unittest
from zope.interface import implementer
from buildbot import interfaces
from buildbot.locks import WorkerLock
from buildbot.process.build import Build
from buildbot.process.buildstep import BuildStep
from buildbot.process.buildstep import create_step_from_step_or_factory
from buildbot.process.locks import get_real_locks_from_accesses
from buildbot.process.metrics import MetricLogObserver
from buildbot.process.properties import Properties
from buildbot.process.results import CANCELLED
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.test.fake import fakemaster
from buildbot.test.fake import fakeprotocol
from buildbot.test.fake import worker
from buildbot.test.reactor import TestReactorMixin
class FakeChange:
def __init__(self, number=None):
self.properties = Properties()
self.number = number
self.who = "me"
class FakeSource:
def __init__(self):
self.sourcestampsetid = None
self.changes = []
self.branch = None
self.revision = None
self.repository = ''
self.codebase = ''
self.project = ''
self.patch_info = None
self.patch = None
def getRepository(self):
return self.repository
class FakeRequest:
def __init__(self):
self.sources = []
self.reason = "Because"
self.properties = Properties()
self.id = 9385
def mergeSourceStampsWith(self, others):
return self.sources
def mergeReasons(self, others):
return self.reason
class FakeBuildStep(BuildStep):
def __init__(self):
super().__init__(
haltOnFailure=False,
flunkOnWarnings=False,
flunkOnFailure=True,
warnOnWarnings=True,
warnOnFailure=False,
alwaysRun=False,
name='fake',
)
self._summary = {'step': 'result', 'build': 'build result'}
self._expected_results = SUCCESS
def run(self):
return self._expected_results
def getResultSummary(self):
return self._summary
def interrupt(self, reason):
self.running = False
self.interrupted = reason
class FakeBuilder:
def __init__(self, master):
self.config = Mock()
self.config.workerbuilddir = 'wbd'
self.config.description = 'builder-description'
self.name = 'fred'
self.master = master
self.botmaster = master.botmaster
self.builderid = 83
self._builders = {}
self.config_version = 0
def getBuilderId(self):
return defer.succeed(self.builderid)
def setup_properties(self, props):
return defer.succeed(None)
def buildFinished(self, build, workerforbuilder):
pass
def getBuilderIdForName(self, name):
return defer.succeed(self._builders.get(name, None) or self.builderid)
def find_project_id(self, name):
return defer.succeed(None)
@implementer(interfaces.IBuildStepFactory)
class FakeStepFactory:
"""Fake step factory that just returns a fixed step object."""
def __init__(self, step):
self.step = step
def buildStep(self):
return self.step
class TestException(Exception):
pass
@implementer(interfaces.IBuildStepFactory)
class FailingStepFactory:
"""Fake step factory that just returns a fixed step object."""
def buildStep(self):
raise TestException("FailingStepFactory")
class _StepController:
def __init__(self, step):
self._step = step
def finishStep(self, result):
self._step._deferred.callback(result)
class _ControllableStep(BuildStep):
def __init__(self):
super().__init__()
self._deferred = defer.Deferred()
def run(self):
return self._deferred
def makeControllableStepFactory():
step = create_step_from_step_or_factory(_ControllableStep())
controller = _StepController(step)
return controller, FakeStepFactory(step)
class TestBuild(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
r = FakeRequest()
r.sources = [FakeSource()]
r.sources[0].changes = [FakeChange()]
r.sources[0].revision = "12345"
self.request = r
self.master = yield fakemaster.make_master(self, wantData=True)
self.worker = worker.FakeWorker(self.master)
self.worker.attached(None)
self.builder = FakeBuilder(self.master)
self.build = Build([r], self.builder)
self.build.conn = fakeprotocol.FakeConnection(self.worker)
self.build.workername = self.worker.workername
self.workerforbuilder = Mock(name='workerforbuilder')
self.workerforbuilder.worker = self.worker
self.workerforbuilder.substantiate_if_needed = lambda _: True
self.workerforbuilder.ping = lambda: True
self.build.workerforbuilder = self.workerforbuilder
self.build.text = []
self.build.buildid = 666
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def assertWorkerPreparationFailure(self, reason):
states = "".join(self.master.data.updates.stepStateString.values())
self.assertIn(states, reason)
def create_fake_build_step(self):
return create_step_from_step_or_factory(FakeBuildStep())
def _setup_lock_claim_log(self, lock, claim_log):
if hasattr(lock, "_old_claim"):
return
def claim(owner, access):
claim_log.append(owner)
return lock._old_claim(owner, access)
lock._old_claim = lock.claim
lock.claim = claim
def testRunSuccessfulBuild(self):
b = self.build
step = self.create_fake_build_step()
b.setStepFactories([FakeStepFactory(step)])
b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, SUCCESS)
def testStopBuild(self):
b = self.build
step = self.create_fake_build_step()
b.setStepFactories([FakeStepFactory(step)])
def startStep(*args, **kw):
# Now interrupt the build
b.stopBuild("stop it")
return defer.Deferred()
step.startStep = startStep
b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, CANCELLED)
self.assertIn('stop it', step.interrupted)
def test_build_retry_when_worker_substantiate_returns_false(self):
b = self.build
step = self.create_fake_build_step()
b.setStepFactories([FakeStepFactory(step)])
self.workerforbuilder.substantiate_if_needed = lambda _: False
b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, RETRY)
self.assertWorkerPreparationFailure('error while worker_prepare')
def test_build_cancelled_when_worker_substantiate_returns_false_due_to_cancel(self):
b = self.build
step = self.create_fake_build_step()
b.setStepFactories([FakeStepFactory(step)])
d = defer.Deferred()
self.workerforbuilder.substantiate_if_needed = lambda _: d
b.startBuild(self.workerforbuilder)
b.stopBuild('Cancel Build', CANCELLED)
d.callback(False)
self.assertEqual(b.results, CANCELLED)
self.assertWorkerPreparationFailure('error while worker_prepare')
def test_build_retry_when_worker_substantiate_returns_false_due_to_cancel(self):
b = self.build
step = self.create_fake_build_step()
b.setStepFactories([FakeStepFactory(step)])
d = defer.Deferred()
self.workerforbuilder.substantiate_if_needed = lambda _: d
b.startBuild(self.workerforbuilder)
b.stopBuild('Cancel Build', RETRY)
d.callback(False)
self.assertEqual(b.results, RETRY)
self.assertWorkerPreparationFailure('error while worker_prepare')
@defer.inlineCallbacks
def testAlwaysRunStepStopBuild(self):
"""Test that steps marked with alwaysRun=True still get run even if
the build is stopped."""
# Create a build with 2 steps, the first one will get interrupted, and
# the second one is marked with alwaysRun=True
b = self.build
step1 = self.create_fake_build_step()
step1.alwaysRun = False
step1.results = None
step2 = self.create_fake_build_step()
step2.alwaysRun = True
step2.results = None
b.setStepFactories([
FakeStepFactory(step1),
FakeStepFactory(step2),
])
def startStep1(*args, **kw):
# Now interrupt the build
b.stopBuild("stop it")
return defer.succeed(SUCCESS)
step1.startStep = startStep1
step1.stepDone = lambda: False
step2Started = [False]
def startStep2(*args, **kw):
step2Started[0] = True
return defer.succeed(SUCCESS)
step2.startStep = startStep2
step1.stepDone = lambda: False
yield b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, CANCELLED)
self.assertIn('stop it', step1.interrupted)
self.assertTrue(step2Started[0])
@defer.inlineCallbacks
def test_start_step_throws_exception(self):
b = self.build
step1 = self.create_fake_build_step()
b.setStepFactories([
FakeStepFactory(step1),
])
def startStep(*args, **kw):
raise TestException()
step1.startStep = startStep
yield b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, EXCEPTION)
self.flushLoggedErrors(TestException)
def testBuilddirPropType(self):
b = self.build
b.builder.config.workerbuilddir = 'test'
self.workerforbuilder.worker.worker_basedir = "/srv/buildbot/worker"
self.workerforbuilder.worker.path_module = posixpath
b.getProperties = Mock()
b.setProperty = Mock()
b.setupWorkerProperties(self.workerforbuilder)
expected_path = '/srv/buildbot/worker/test'
b.setProperty.assert_has_calls([call('builddir', expected_path, 'Worker')], any_order=True)
@defer.inlineCallbacks
def testBuildLocksAcquired(self):
b = self.build
lock = WorkerLock('lock')
claim_log = []
lock_access = lock.access('counting')
lock.access = lambda mode: lock_access
b.setLocks([lock_access])
yield b._setup_locks()
self._setup_lock_claim_log(b._locks_to_acquire[0][0], claim_log)
step = self.create_fake_build_step()
b.setStepFactories([FakeStepFactory(step)])
b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, SUCCESS)
self.assertEqual(len(claim_log), 1)
@defer.inlineCallbacks
def testBuildLocksOrder(self):
"""Test that locks are acquired in FIFO order; specifically that
counting locks cannot jump ahead of exclusive locks"""
eBuild = self.build
cBuilder = FakeBuilder(self.master)
cBuild = Build([self.request], cBuilder)
cBuild.workerforbuilder = self.workerforbuilder
cBuild.workername = self.worker.workername
eWorker = Mock()
cWorker = Mock()
eWorker.worker = self.worker
cWorker.worker = self.worker
eWorker.substantiate_if_needed = cWorker.substantiate_if_needed = lambda _: True
eWorker.ping = cWorker.ping = lambda: True
lock = WorkerLock('lock', 2)
claim_log = []
eBuild.setLocks([lock.access('exclusive')])
yield eBuild._setup_locks()
cBuild.setLocks([lock.access('counting')])
yield cBuild._setup_locks()
self._setup_lock_claim_log(eBuild._locks_to_acquire[0][0], claim_log)
self._setup_lock_claim_log(cBuild._locks_to_acquire[0][0], claim_log)
real_lock = eBuild._locks_to_acquire[0][0]
b3 = Mock()
b3_access = lock.access('counting')
real_lock.claim(b3, b3_access)
step = self.create_fake_build_step()
eBuild.setStepFactories([FakeStepFactory(step)])
cBuild.setStepFactories([FakeStepFactory(step)])
e = eBuild.startBuild(eWorker)
c = cBuild.startBuild(cWorker)
d = defer.DeferredList([e, c])
real_lock.release(b3, b3_access)
yield d
self.assertEqual(eBuild.results, SUCCESS)
self.assertEqual(cBuild.results, SUCCESS)
self.assertEqual(claim_log, [b3, eBuild, cBuild])
@defer.inlineCallbacks
def testBuildWaitingForLocks(self):
b = self.build
claim_log = []
lock = WorkerLock('lock')
lock_access = lock.access('counting')
b.setLocks([lock_access])
yield b._setup_locks()
self._setup_lock_claim_log(b._locks_to_acquire[0][0], claim_log)
step = self.create_fake_build_step()
b.setStepFactories([FakeStepFactory(step)])
real_lock = b._locks_to_acquire[0][0]
real_lock.claim(Mock(), lock.access('counting'))
b.startBuild(self.workerforbuilder)
self.assertEqual(len(claim_log), 1)
self.assertTrue(b.currentStep is None)
self.assertTrue(b._acquiringLock is not None)
@defer.inlineCallbacks
def testStopBuildWaitingForLocks(self):
b = self.build
lock = WorkerLock('lock')
lock_access = lock.access('counting')
b.setLocks([lock_access])
yield b._setup_locks()
step = self.create_fake_build_step()
step.alwaysRun = False
b.setStepFactories([FakeStepFactory(step)])
real_lock = b._locks_to_acquire[0][0]
real_lock.claim(Mock(), lock.access('counting'))
def acquireLocks(res=None):
retval = Build.acquireLocks(b, res)
b.stopBuild('stop it')
return retval
b.acquireLocks = acquireLocks
b.startBuild(self.workerforbuilder)
self.assertTrue(b.currentStep is None)
self.assertEqual(b.results, CANCELLED)
@defer.inlineCallbacks
def testStopBuildWaitingForLocks_lostRemote(self):
b = self.build
lock = WorkerLock('lock')
lock_access = lock.access('counting')
lock.access = lambda mode: lock_access
b.setLocks([lock_access])
yield b._setup_locks()
step = self.create_fake_build_step()
step.alwaysRun = False
b.setStepFactories([FakeStepFactory(step)])
real_lock = b._locks_to_acquire[0][0]
real_lock.claim(Mock(), lock.access('counting'))
def acquireLocks(res=None):
retval = Build.acquireLocks(b, res)
b.lostRemote()
return retval
b.acquireLocks = acquireLocks
b.startBuild(self.workerforbuilder)
self.assertTrue(b.currentStep is None)
self.assertEqual(b.results, RETRY)
@defer.inlineCallbacks
def testStopBuildWaitingForStepLocks(self):
b = self.build
lock = WorkerLock('lock')
lock_access = lock.access('counting')
locks = yield get_real_locks_from_accesses([lock_access], b)
step = create_step_from_step_or_factory(BuildStep(locks=[lock_access]))
b.setStepFactories([FakeStepFactory(step)])
locks[0][0].claim(Mock(), lock.access('counting'))
gotLocks = [False]
def acquireLocks(res=None):
gotLocks[0] = True
retval = BuildStep.acquireLocks(step, res)
self.assertTrue(b.currentStep is step)
b.stopBuild('stop it')
return retval
step.acquireLocks = acquireLocks
b.startBuild(self.workerforbuilder)
self.assertEqual(gotLocks, [True])
self.assertEqual(b.results, CANCELLED)
def testStepDone(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
terminate = b.stepDone(SUCCESS, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, SUCCESS)
def testStepDoneHaltOnFailure(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
step.haltOnFailure = True
terminate = b.stepDone(FAILURE, step)
self.assertTrue(terminate.result)
self.assertEqual(b.results, FAILURE)
def testStepDoneHaltOnFailureNoFlunkOnFailure(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
step.flunkOnFailure = False
step.haltOnFailure = True
terminate = b.stepDone(FAILURE, step)
self.assertTrue(terminate.result)
self.assertEqual(b.results, SUCCESS)
def testStepDoneFlunkOnWarningsFlunkOnFailure(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
step.flunkOnFailure = True
step.flunkOnWarnings = True
b.stepDone(WARNINGS, step)
terminate = b.stepDone(FAILURE, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, FAILURE)
def testStepDoneNoWarnOnWarnings(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
step.warnOnWarnings = False
terminate = b.stepDone(WARNINGS, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, SUCCESS)
def testStepDoneWarnings(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
terminate = b.stepDone(WARNINGS, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, WARNINGS)
def testStepDoneFail(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
terminate = b.stepDone(FAILURE, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, FAILURE)
def testStepDoneFailOverridesWarnings(self):
b = self.build
b.results = WARNINGS
step = self.create_fake_build_step()
terminate = b.stepDone(FAILURE, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, FAILURE)
def testStepDoneWarnOnFailure(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
step.warnOnFailure = True
step.flunkOnFailure = False
terminate = b.stepDone(FAILURE, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, WARNINGS)
def testStepDoneFlunkOnWarnings(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
step.flunkOnWarnings = True
terminate = b.stepDone(WARNINGS, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, FAILURE)
def testStepDoneHaltOnFailureFlunkOnWarnings(self):
b = self.build
b.results = SUCCESS
step = self.create_fake_build_step()
step.flunkOnWarnings = True
self.haltOnFailure = True
terminate = b.stepDone(WARNINGS, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, FAILURE)
def testStepDoneWarningsDontOverrideFailure(self):
b = self.build
b.results = FAILURE
step = self.create_fake_build_step()
terminate = b.stepDone(WARNINGS, step)
self.assertFalse(terminate.result)
self.assertEqual(b.results, FAILURE)
def testStepDoneRetryOverridesAnythingElse(self):
b = self.build
b.results = RETRY
step = self.create_fake_build_step()
step.alwaysRun = True
b.stepDone(WARNINGS, step)
b.stepDone(FAILURE, step)
b.stepDone(SUCCESS, step)
terminate = b.stepDone(EXCEPTION, step)
self.assertTrue(terminate.result)
self.assertEqual(b.results, RETRY)
def test_getSummaryStatistic(self):
b = self.build
b.executedSteps = [BuildStep(), BuildStep(), BuildStep()]
b.executedSteps[0].setStatistic('casualties', 7)
b.executedSteps[2].setStatistic('casualties', 4)
add = operator.add
self.assertEqual(b.getSummaryStatistic('casualties', add), 11)
self.assertEqual(b.getSummaryStatistic('casualties', add, 10), 21)
def create_fake_steps(self, names):
steps = []
def create_fake_step(name):
step = self.create_fake_build_step()
step.name = name
return step
for name in names:
step = create_fake_step(name)
steps.append(step)
return steps
@defer.inlineCallbacks
def test_start_build_sets_properties(self):
b = self.build
b.setProperty("foo", "bar", "test")
step = create_step_from_step_or_factory(self.create_fake_build_step())
b.setStepFactories([FakeStepFactory(step)])
yield b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, SUCCESS)
# remove duplicates, note that set() can't be used as properties contain complex
# data structures. Also, remove builddir which depends on the platform
got_properties = []
for prop in sorted(self.master.data.updates.properties):
if prop not in got_properties and prop[1] != 'builddir':
got_properties.append(prop)
self.assertEqual(
got_properties,
[
(10, 'basedir', '/wrk', 'Worker'),
(10, 'branch', None, 'Build'),
(10, 'buildnumber', 1, 'Build'),
(10, 'codebase', '', 'Build'),
(10, 'foo', 'bar', 'test'), # custom property
(10, 'owners', ['me'], 'Build'),
(10, 'project', '', 'Build'),
(10, 'repository', '', 'Build'),
(10, 'revision', '12345', 'Build'),
],
)
@defer.inlineCallbacks
def testAddStepsAfterCurrentStep(self):
b = self.build
steps = self.create_fake_steps(["a", "b", "c"])
def startStepB(*args, **kw):
new_steps = self.create_fake_steps(["d", "e"])
b.addStepsAfterCurrentStep([FakeStepFactory(s) for s in new_steps])
return SUCCESS
steps[1].startStep = startStepB
b.setStepFactories([FakeStepFactory(s) for s in steps])
yield b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, SUCCESS)
expected_names = ["a", "b", "d", "e", "c"]
executed_names = [s.name for s in b.executedSteps]
self.assertEqual(executed_names, expected_names)
@defer.inlineCallbacks
def testAddStepsAfterLastStep(self):
b = self.build
steps = self.create_fake_steps(["a", "b", "c"])
def startStepB(*args, **kw):
new_steps = self.create_fake_steps(["d", "e"])
b.addStepsAfterLastStep([FakeStepFactory(s) for s in new_steps])
return SUCCESS
steps[1].startStep = startStepB
b.setStepFactories([FakeStepFactory(s) for s in steps])
yield b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, SUCCESS)
expected_names = ["a", "b", "c", "d", "e"]
executed_names = [s.name for s in b.executedSteps]
self.assertEqual(executed_names, expected_names)
def testStepNamesUnique(self):
# if the step names are unique they should remain unchanged
b = self.build
steps = self.create_fake_steps(["clone", "command", "clean"])
b.setStepFactories([FakeStepFactory(s) for s in steps])
b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, SUCCESS)
expected_names = ["clone", "command", "clean"]
executed_names = [s.name for s in b.executedSteps]
self.assertEqual(executed_names, expected_names)
def testStepNamesDuplicate(self):
b = self.build
steps = self.create_fake_steps(["stage", "stage", "stage"])
b.setStepFactories([FakeStepFactory(s) for s in steps])
b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, SUCCESS)
expected_names = ["stage", "stage_1", "stage_2"]
executed_names = [s.name for s in b.executedSteps]
self.assertEqual(executed_names, expected_names)
def testStepNamesDuplicateAfterAdd(self):
b = self.build
steps = self.create_fake_steps(["a", "b", "c"])
def startStepB(*args, **kw):
new_steps = self.create_fake_steps(["c", "c"])
b.addStepsAfterCurrentStep([FakeStepFactory(s) for s in new_steps])
return SUCCESS
steps[1].startStep = startStepB
b.setStepFactories([FakeStepFactory(s) for s in steps])
b.startBuild(self.workerforbuilder)
self.assertEqual(b.results, SUCCESS)
expected_names = ["a", "b", "c", "c_1", "c_2"]
executed_names = [s.name for s in b.executedSteps]
self.assertEqual(executed_names, expected_names)
@defer.inlineCallbacks
def testGetUrl(self):
self.build.number = 3
url = yield self.build.getUrl()
self.assertEqual(url, 'http://localhost:8080/#/builders/83/builds/3')
@defer.inlineCallbacks
def testGetUrlForVirtualBuilder(self):
# Let's fake a virtual builder
self.builder._builders['wilma'] = 108
self.build.setProperty('virtual_builder_name', 'wilma', 'Build')
self.build.setProperty('virtual_builder_tags', ['_virtual_'])
self.build.number = 33
url = yield self.build.getUrl()
self.assertEqual(url, 'http://localhost:8080/#/builders/108/builds/33')
def test_active_builds_metric(self):
"""
The number of active builds is increased when a build starts
and decreased when it finishes.
"""
b = self.build
controller, step_factory = makeControllableStepFactory()
b.setStepFactories([step_factory])
observer = MetricLogObserver()
observer.enable()
self.addCleanup(observer.disable)
def get_active_builds():
return observer.asDict()['counters'].get('active_builds', 0)
self.assertEqual(get_active_builds(), 0)
b.startBuild(self.workerforbuilder)
self.assertEqual(get_active_builds(), 1)
controller.finishStep(SUCCESS)
self.assertEqual(get_active_builds(), 0)
def test_active_builds_metric_failure(self):
"""
The number of active builds is increased when a build starts
and decreased when it finishes..
"""
b = self.build
b.setStepFactories([FailingStepFactory()])
observer = MetricLogObserver()
observer.enable()
self.addCleanup(observer.disable)
def get_active_builds():
return observer.asDict()['counters'].get('active_builds', 0)
self.assertEqual(get_active_builds(), 0)
b.startBuild(self.workerforbuilder)
self.flushLoggedErrors(TestException)
self.assertEqual(get_active_builds(), 0)
class TestMultipleSourceStamps(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self)
self.builder = FakeBuilder(self.master)
r = FakeRequest()
s1 = FakeSource()
s1.repository = "repoA"
s1.codebase = "A"
s1.changes = [FakeChange(10), FakeChange(11)]
s1.revision = "12345"
s2 = FakeSource()
s2.repository = "repoB"
s2.codebase = "B"
s2.changes = [FakeChange(12), FakeChange(13)]
s2.revision = "67890"
s3 = FakeSource()
s3.repository = "repoC"
# no codebase defined
s3.changes = [FakeChange(14), FakeChange(15)]
s3.revision = "111213"
r.sources.extend([s1, s2, s3])
self.build = Build([r], self.builder)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def test_buildReturnSourceStamp(self):
"""
Test that a build returns the correct sourcestamp
"""
source1 = self.build.getSourceStamp("A")
source2 = self.build.getSourceStamp("B")
self.assertEqual([source1.repository, source1.revision], ["repoA", "12345"])
self.assertEqual([source2.repository, source2.revision], ["repoB", "67890"])
def test_buildReturnSourceStamp_empty_codebase(self):
"""
Test that a build returns the correct sourcestamp if codebase is empty
"""
codebase = ''
source3 = self.build.getSourceStamp(codebase)
self.assertTrue(source3 is not None)
self.assertEqual([source3.repository, source3.revision], ["repoC", "111213"])
class TestBuildBlameList(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self)
self.builder = FakeBuilder(self.master)
self.sourceByMe = FakeSource()
self.sourceByMe.repository = "repoA"
self.sourceByMe.codebase = "A"
self.sourceByMe.changes = [FakeChange(10), FakeChange(11)]
self.sourceByMe.changes[0].who = "me"
self.sourceByMe.changes[1].who = "me"
self.sourceByHim = FakeSource()
self.sourceByHim.repository = "repoB"
self.sourceByHim.codebase = "B"
self.sourceByHim.changes = [FakeChange(12), FakeChange(13)]
self.sourceByHim.changes[0].who = "him"
self.sourceByHim.changes[1].who = "him"
self.patchSource = FakeSource()
self.patchSource.repository = "repoB"
self.patchSource.codebase = "B"
self.patchSource.changes = []
self.patchSource.revision = "67890"
self.patchSource.patch_info = ("jeff", "jeff's new feature")
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def test_blamelist_for_changes(self):
r = FakeRequest()
r.sources.extend([self.sourceByMe, self.sourceByHim])
build = Build([r], self.builder)
blamelist = build.blamelist()
self.assertEqual(blamelist, ['him', 'me'])
def test_blamelist_for_patch(self):
r = FakeRequest()
r.sources.extend([self.patchSource])
build = Build([r], self.builder)
blamelist = build.blamelist()
# If no patch is set, author will not be est
self.assertEqual(blamelist, [])
class TestSetupProperties_MultipleSources(TestReactorMixin, unittest.TestCase):
"""
Test that the property values, based on the available requests, are
initialized properly
"""
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.props = {}
self.r = FakeRequest()
self.r.sources = []
self.r.sources.append(FakeSource())
self.r.sources[0].changes = [FakeChange()]
self.r.sources[0].repository = "http://svn-repo-A"
self.r.sources[0].codebase = "A"
self.r.sources[0].branch = "develop"
self.r.sources[0].revision = "12345"
self.r.sources.append(FakeSource())
self.r.sources[1].changes = [FakeChange()]
self.r.sources[1].repository = "http://svn-repo-B"
self.r.sources[1].codebase = "B"
self.r.sources[1].revision = "34567"
self.builder = FakeBuilder((yield fakemaster.make_master(self, wantData=True)))
self.build = Build([self.r], self.builder)
self.build.setStepFactories([])
# record properties that will be set
self.build.properties.setProperty = self.setProperty
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def setProperty(self, n, v, s, runtime=False):
if s not in self.props:
self.props[s] = {}
if not self.props[s]:
self.props[s] = {}
self.props[s][n] = v
def test_sourcestamp_properties_not_set(self):
Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources)
self.assertNotIn("codebase", self.props["Build"])
self.assertNotIn("revision", self.props["Build"])
self.assertNotIn("branch", self.props["Build"])
self.assertNotIn("project", self.props["Build"])
self.assertNotIn("repository", self.props["Build"])
class TestSetupProperties_SingleSource(TestReactorMixin, unittest.TestCase):
"""
Test that the property values, based on the available requests, are
initialized properly
"""
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.props = {}
self.r = FakeRequest()
self.r.sources = []
self.r.sources.append(FakeSource())
self.r.sources[0].changes = [FakeChange()]
self.r.sources[0].repository = "http://svn-repo-A"
self.r.sources[0].codebase = "A"
self.r.sources[0].branch = "develop"
self.r.sources[0].revision = "12345"
self.builder = FakeBuilder((yield fakemaster.make_master(self, wantData=True)))
self.build = Build([self.r], self.builder)
self.build.setStepFactories([])
# record properties that will be set
self.build.properties.setProperty = self.setProperty
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def setProperty(self, n, v, s, runtime=False):
if s not in self.props:
self.props[s] = {}
if not self.props[s]:
self.props[s] = {}
self.props[s][n] = v
def test_properties_codebase(self):
Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources)
codebase = self.props["Build"]["codebase"]
self.assertEqual(codebase, "A")
def test_properties_repository(self):
Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources)
repository = self.props["Build"]["repository"]
self.assertEqual(repository, "http://svn-repo-A")
def test_properties_revision(self):
Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources)
revision = self.props["Build"]["revision"]
self.assertEqual(revision, "12345")
def test_properties_branch(self):
Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources)
branch = self.props["Build"]["branch"]
self.assertEqual(branch, "develop")
def test_property_project(self):
Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources)
project = self.props["Build"]["project"]
self.assertEqual(project, '')
| 36,111 | Python | .py | 852 | 33.850939 | 99 | 0.652329 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,439 | test_users_users.py | buildbot_buildbot/master/buildbot/test/unit/process/test_users_users.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import copy
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db.users import UserModel
from buildbot.process.users import users
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
class UsersTests(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantDb=True)
self.db = self.master.db
self.test_sha = users.encrypt("cancer")
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def verify_users(self, users):
users_no_attrs = copy.deepcopy(users)
for user in users_no_attrs:
user.attributes = None
got_users = yield self.db.users.getUsers()
self.assertEqual(got_users, users_no_attrs)
for user in users:
got_user = yield self.db.users.getUser(user.uid)
self.assertEqual(got_user, user)
@defer.inlineCallbacks
def test_createUserObject_no_src(self):
yield users.createUserObject(self.master, "Tyler Durden", None)
got_users = yield self.db.users.getUsers()
self.assertEqual(got_users, [])
@defer.inlineCallbacks
def test_createUserObject_unrecognized_src(self):
yield users.createUserObject(self.master, "Tyler Durden", 'blah')
got_users = yield self.db.users.getUsers()
self.assertEqual(got_users, [])
@defer.inlineCallbacks
def test_createUserObject_git(self):
yield users.createUserObject(self.master, "Tyler Durden <[email protected]>", 'git')
yield self.verify_users([
UserModel(
uid=1,
identifier='Tyler Durden <[email protected]>',
bb_username=None,
bb_password=None,
attributes={'git': 'Tyler Durden <[email protected]>'},
)
])
@defer.inlineCallbacks
def test_createUserObject_svn(self):
yield users.createUserObject(self.master, "tdurden", 'svn')
yield self.verify_users([
UserModel(
uid=1,
identifier='tdurden',
bb_username=None,
bb_password=None,
attributes={'svn': 'tdurden'},
)
])
@defer.inlineCallbacks
def test_createUserObject_hg(self):
yield users.createUserObject(self.master, "Tyler Durden <[email protected]>", 'hg')
yield self.verify_users([
UserModel(
uid=1,
identifier='Tyler Durden <[email protected]>',
bb_username=None,
bb_password=None,
attributes={'hg': 'Tyler Durden <[email protected]>'},
)
])
@defer.inlineCallbacks
def test_createUserObject_cvs(self):
yield users.createUserObject(self.master, "tdurden", 'cvs')
yield self.verify_users([
UserModel(
uid=1,
identifier='tdurden',
bb_username=None,
bb_password=None,
attributes={'cvs': 'tdurden'},
)
])
@defer.inlineCallbacks
def test_createUserObject_darcs(self):
yield users.createUserObject(self.master, "[email protected]", 'darcs')
yield self.verify_users([
UserModel(
uid=1,
identifier='[email protected]',
bb_username=None,
bb_password=None,
attributes={'darcs': '[email protected]'},
)
])
@defer.inlineCallbacks
def test_createUserObject_bzr(self):
yield users.createUserObject(self.master, "Tyler Durden", 'bzr')
yield self.verify_users([
UserModel(
uid=1,
identifier='Tyler Durden',
bb_username=None,
bb_password=None,
attributes={'bzr': 'Tyler Durden'},
)
])
@defer.inlineCallbacks
def test_getUserContact_found(self):
yield self.db.insert_test_data([
fakedb.User(uid=1, identifier='tdurden'),
fakedb.UserInfo(uid=1, attr_type='svn', attr_data='tdurden'),
fakedb.UserInfo(uid=1, attr_type='email', attr_data='[email protected]'),
])
contact = yield users.getUserContact(self.master, contact_types=['email'], uid=1)
self.assertEqual(contact, '[email protected]')
@defer.inlineCallbacks
def test_getUserContact_key_not_found(self):
yield self.db.insert_test_data([
fakedb.User(uid=1, identifier='tdurden'),
fakedb.UserInfo(uid=1, attr_type='svn', attr_data='tdurden'),
fakedb.UserInfo(uid=1, attr_type='email', attr_data='[email protected]'),
])
contact = yield users.getUserContact(self.master, contact_types=['blargh'], uid=1)
self.assertEqual(contact, None)
@defer.inlineCallbacks
def test_getUserContact_uid_not_found(self):
contact = yield users.getUserContact(self.master, contact_types=['email'], uid=1)
self.assertEqual(contact, None)
def test_check_passwd(self):
res = users.check_passwd("cancer", self.test_sha)
self.assertEqual(res, True)
| 6,156 | Python | .py | 149 | 31.959732 | 91 | 0.632319 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,440 | test_buildrequestdistributor.py | buildbot_buildbot/master/buildbot/test/unit/process/test_buildrequestdistributor.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import random
from unittest import mock
from parameterized import parameterized
from twisted.internet import defer
from twisted.python import failure
from twisted.trial import unittest
from buildbot import config
from buildbot.db import buildrequests
from buildbot.process import buildrequestdistributor
from buildbot.process import factory
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.util import epoch2datetime
from buildbot.util.eventual import fireEventually
from buildbot.util.twisted import async_to_deferred
def nth_worker(n):
def pick_nth_by_name(builder, workers=None, br=None):
if workers is None:
workers = builder
workers = workers[:]
workers.sort(key=lambda a: a.name)
return workers[n]
return pick_nth_by_name
class TestBRDBase(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
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 = yield 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),
]
@defer.inlineCallbacks
def tearDown(self):
if self.brd.running:
yield self.brd.stopService()
yield self.tear_down_test_reactor()
def make_workers(self, worker_count):
rows = self.base_rows[:]
for i in range(worker_count):
self.addWorkers({f'test-worker{i}': 1})
rows.append(fakedb.Buildset(id=100 + i, reason='because'))
rows.append(fakedb.BuildsetSourceStamp(buildsetid=100 + i, sourcestampid=21))
rows.append(fakedb.BuildRequest(id=10 + i, buildsetid=100 + i, builderid=77))
return rows
def addWorkers(self, workerforbuilders):
"""C{workerforbuilders} maps name : available"""
for name, avail in workerforbuilders.items():
wfb = mock.Mock(spec=['isAvailable'], name=name)
wfb.name = name
wfb.isAvailable.return_value = avail
for bldr in self.builders.values():
bldr.workers.append(wfb)
@defer.inlineCallbacks
def createBuilder(self, name, builderid=None, builder_config=None):
if builderid is None:
b = fakedb.Builder(name=name)
yield self.master.db.insert_test_data([b])
builderid = b.id
bldr = mock.Mock(name=name)
bldr.name = name
self.botmaster.builders[name] = bldr
self.builders[name] = bldr
def maybeStartBuild(worker, builds):
worker.isAvailable.return_value = False
self.startedBuilds.append((worker.name, builds))
d = defer.Deferred()
self.reactor.callLater(0, d.callback, True)
return d
bldr.maybeStartBuild = maybeStartBuild
bldr.getCollapseRequestsFn = lambda: False
bldr.workers = []
bldr.getAvailableWorkers = lambda: [w for w in bldr.workers if w.isAvailable()]
bldr.getBuilderId = lambda: (builderid)
if builder_config is None:
bldr.config.nextWorker = None
bldr.config.nextBuild = None
else:
bldr.config = builder_config
def canStartBuild(*args):
can = bldr.config.canStartBuild
return not can or can(*args)
bldr.canStartBuild = canStartBuild
return bldr
@defer.inlineCallbacks
def addBuilders(self, names):
self.startedBuilds = []
for name in names:
yield self.createBuilder(name)
def assertMyClaims(self, brids):
self.assertEqual(self.master.data.updates.claimedBuildRequests, set(brids))
class Test(TestBRDBase):
def checkAllCleanedUp(self):
# check that the BRD didn't end with a stuck lock or in the 'active' state (which would mean
# it ended without unwinding correctly)
self.assertEqual(self.brd.pending_builders_lock.locked, False)
self.assertEqual(self.brd.activity_lock.locked, False)
self.assertEqual(self.brd.active, False)
def useMock_maybeStartBuildsOnBuilder(self):
# sets up a mock "maybeStartBuildsOnBuilder" so we can track
# how the method gets invoked
# keep track of the calls to brd.maybeStartBuildsOnBuilder
self.maybeStartBuildsOnBuilder_calls = []
def maybeStartBuildsOnBuilder(bldr):
self.assertIdentical(self.builders[bldr.name], bldr)
self.maybeStartBuildsOnBuilder_calls.append(bldr.name)
return fireEventually()
self.brd._maybeStartBuildsOnBuilder = maybeStartBuildsOnBuilder
def removeBuilder(self, name):
del self.builders[name]
del self.botmaster.builders[name]
# tests
@defer.inlineCallbacks
def test_maybeStartBuildsOn_simple(self):
self.useMock_maybeStartBuildsOnBuilder()
self.addBuilders(['bldr1'])
yield self.brd.maybeStartBuildsOn(['bldr1'])
yield self.brd._waitForFinish()
self.assertEqual(self.maybeStartBuildsOnBuilder_calls, ['bldr1'])
self.checkAllCleanedUp()
@defer.inlineCallbacks
def test_maybeStartBuildsOn_parallel(self):
# test 15 "parallel" invocations of maybeStartBuildsOn, with a
# _sortBuilders that takes a while. This is a regression test for bug
# 1979.
builders = [f'bldr{i:02}' for i in range(15)]
def slow_sorter(master, bldrs):
bldrs.sort(key=lambda b1: b1.name)
d = defer.Deferred()
self.reactor.callLater(0, d.callback, bldrs)
def done(_):
return _
d.addCallback(done)
return d
self.master.config.prioritizeBuilders = slow_sorter
self.useMock_maybeStartBuildsOnBuilder()
self.addBuilders(builders)
for bldr in builders:
yield self.brd.maybeStartBuildsOn([bldr])
yield self.brd._waitForFinish()
self.assertEqual(self.maybeStartBuildsOnBuilder_calls, builders)
self.checkAllCleanedUp()
@defer.inlineCallbacks
def test_maybeStartBuildsOn_exception(self):
self.addBuilders(['bldr1'])
async def _maybeStartBuildsOnBuilder(n):
# fail slowly, so that the activity loop doesn't exit too soon
d = defer.Deferred()
self.reactor.callLater(0, d.errback, failure.Failure(RuntimeError("oh noes")))
await d
self.brd._maybeStartBuildsOnBuilder = _maybeStartBuildsOnBuilder
yield self.brd.maybeStartBuildsOn(['bldr1'])
yield self.brd._waitForFinish()
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
self.checkAllCleanedUp()
@defer.inlineCallbacks
def test_maybeStartBuildsOn_collapsing(self):
self.useMock_maybeStartBuildsOnBuilder()
self.addBuilders(['bldr1', 'bldr2', 'bldr3'])
yield self.brd.maybeStartBuildsOn(['bldr3'])
yield self.brd.maybeStartBuildsOn(['bldr2', 'bldr1'])
yield self.brd.maybeStartBuildsOn(['bldr4']) # should be ignored
yield self.brd.maybeStartBuildsOn(['bldr2']) # already queued - ignored
yield self.brd.maybeStartBuildsOn(['bldr3', 'bldr2'])
yield self.brd._waitForFinish()
# bldr3 gets invoked twice, since it's considered to have started
# already when the first call to maybeStartBuildsOn returns
self.assertEqual(self.maybeStartBuildsOnBuilder_calls, ['bldr3', 'bldr1', 'bldr2', 'bldr3'])
self.checkAllCleanedUp()
@defer.inlineCallbacks
def test_maybeStartBuildsOn_builders_missing(self):
self.useMock_maybeStartBuildsOnBuilder()
self.addBuilders(['bldr1', 'bldr2', 'bldr3'])
yield self.brd.maybeStartBuildsOn(['bldr1', 'bldr2', 'bldr3'])
# bldr1 is already run, so surreptitiously remove the other
# two - nothing should crash, but the builders should not run
self.removeBuilder('bldr2')
self.removeBuilder('bldr3')
yield self.brd._waitForFinish()
self.assertEqual(self.maybeStartBuildsOnBuilder_calls, ['bldr1'])
self.checkAllCleanedUp()
@defer.inlineCallbacks
def do_test_sortBuilders(
self,
prioritizeBuilders,
oldestRequestTimes,
highestPriorities,
expected,
returnDeferred=False,
):
self.useMock_maybeStartBuildsOnBuilder()
self.addBuilders(list(oldestRequestTimes))
self.master.config.prioritizeBuilders = prioritizeBuilders
def mklambda(t): # work around variable-binding issues
if returnDeferred:
return lambda: defer.succeed(t)
return lambda: t
for n, t in oldestRequestTimes.items():
if t is not None:
t = epoch2datetime(t)
self.builders[n].getOldestRequestTime = mklambda(t)
for n, t in highestPriorities.items():
self.builders[n].get_highest_priority = mklambda(t)
result = yield self.brd._sortBuilders(list(oldestRequestTimes))
self.assertEqual(result, expected)
self.checkAllCleanedUp()
def test_sortBuilders_default_sync(self):
return self.do_test_sortBuilders(
None, # use the default sort
{"bldr1": 777, "bldr2": 999, "bldr3": 888},
{"bldr1": 10, "bldr2": 15, "bldr3": 5},
['bldr2', 'bldr1', 'bldr3'],
)
def test_sortBuilders_default_asyn(self):
return self.do_test_sortBuilders(
None, # use the default sort
{"bldr1": 777, "bldr2": 999, "bldr3": 888},
{"bldr1": 10, "bldr2": 15, "bldr3": 5},
['bldr2', 'bldr1', 'bldr3'],
returnDeferred=True,
)
def test_sortBuilders_default_None(self):
return self.do_test_sortBuilders(
None, # use the default sort
{"bldr1": 777, "bldr2": None, "bldr3": 888},
{"bldr1": 10, "bldr2": None, "bldr3": 5},
['bldr1', 'bldr3', 'bldr2'],
)
def test_sortBuilders_default_priority_match(self):
return self.do_test_sortBuilders(
None, # use the default sort
{"bldr1": 777, "bldr2": 999, "bldr3": 888},
{"bldr1": 10, "bldr2": 10, "bldr3": 10},
['bldr1', 'bldr3', 'bldr2'],
)
def test_sortBuilders_custom(self):
def prioritizeBuilders(master, builders):
self.assertIdentical(master, self.master)
return sorted(builders, key=lambda b: b.name)
return self.do_test_sortBuilders(
prioritizeBuilders,
{"bldr1": 1, "bldr2": 1, "bldr3": 1},
{"bldr1": 10, "bldr2": 15, "bldr3": 5},
['bldr1', 'bldr2', 'bldr3'],
)
def test_sortBuilders_custom_async(self):
def prioritizeBuilders(master, builders):
self.assertIdentical(master, self.master)
return defer.succeed(sorted(builders, key=lambda b: b.name))
return self.do_test_sortBuilders(
prioritizeBuilders,
{"bldr1": 1, "bldr2": 1, "bldr3": 1},
{"bldr1": 10, "bldr2": 15, "bldr3": 5},
['bldr1', 'bldr2', 'bldr3'],
)
@defer.inlineCallbacks
def test_sortBuilders_custom_exception(self):
self.useMock_maybeStartBuildsOnBuilder()
self.addBuilders(['x', 'y'])
def fail(m, b):
raise RuntimeError("oh noes")
self.master.config.prioritizeBuilders = fail
# expect to get the builders back in the same order in the event of an
# exception
result = yield self.brd._sortBuilders(['y', 'x'])
self.assertEqual(result, ['y', 'x'])
# and expect the exception to be logged
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
@defer.inlineCallbacks
def test_stopService(self):
# check that stopService waits for a builder run to complete, but does not
# allow a subsequent run to start
self.useMock_maybeStartBuildsOnBuilder()
self.addBuilders(['A', 'B'])
oldMSBOB = self.brd._maybeStartBuildsOnBuilder
def maybeStartBuildsOnBuilder(bldr):
d = oldMSBOB(bldr)
stop_d = self.brd.stopService()
stop_d.addCallback(lambda _: self.maybeStartBuildsOnBuilder_calls.append('(stopped)'))
d.addCallback(lambda _: self.maybeStartBuildsOnBuilder_calls.append('finished'))
return d
self.brd._maybeStartBuildsOnBuilder = maybeStartBuildsOnBuilder
# start both builds; A should start and complete *before* the service stops,
# and B should not run.
yield self.brd.maybeStartBuildsOn(['A', 'B'])
yield self.brd._waitForFinish()
self.assertEqual(self.maybeStartBuildsOnBuilder_calls, ['A', 'finished', '(stopped)'])
class TestMaybeStartBuilds(TestBRDBase):
@defer.inlineCallbacks
def setUp(self):
yield super().setUp()
self.startedBuilds = []
self.bldr = yield self.createBuilder('A', builderid=77)
self.builders['A'] = self.bldr
def assertBuildsStarted(self, exp):
# munge builds_started into (worker, [brids])
builds_started = [
(worker, [br.id for br in breqs]) for (worker, breqs) in self.startedBuilds
]
self.assertEqual(builds_started, exp)
# _maybeStartBuildsOnBuilder
@async_to_deferred
async def do_test_maybeStartBuildsOnBuilder(self, rows=None, exp_claims=None, exp_builds=None):
rows = rows or []
exp_claims = exp_claims or []
exp_builds = exp_builds or []
await self.master.db.insert_test_data(rows)
await self.brd._maybeStartBuildsOnBuilder(self.bldr)
self.assertMyClaims(exp_claims)
self.assertBuildsStarted(exp_builds)
@defer.inlineCallbacks
def test_no_buildrequests(self):
self.addWorkers({'test-worker11': 1})
yield self.do_test_maybeStartBuildsOnBuilder(exp_claims=[], exp_builds=[])
@defer.inlineCallbacks
def test_no_workerforbuilders(self):
rows = [
fakedb.Builder(id=78, name='bldr'),
fakedb.BuildRequest(id=11, buildsetid=10, builderid=78),
]
yield self.do_test_maybeStartBuildsOnBuilder(rows=rows, exp_claims=[], exp_builds=[])
@defer.inlineCallbacks
def test_limited_by_workers(self):
self.addWorkers({'test-worker1': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows, exp_claims=[10], exp_builds=[('test-worker1', [10])]
)
@defer.inlineCallbacks
def test_sorted_by_submit_time(self):
# same as "limited_by_workers" but with rows swapped
self.addWorkers({'test-worker1': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows, exp_claims=[10], exp_builds=[('test-worker1', [10])]
)
@defer.inlineCallbacks
def test_limited_by_available_workers(self):
self.addWorkers({'test-worker1': 0, 'test-worker2': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows, exp_claims=[10], exp_builds=[('test-worker2', [10])]
)
@defer.inlineCallbacks
def test_slow_db(self):
# test what happens if the "getBuildRequests" fetch takes a "long time"
self.addWorkers({'test-worker1': 1})
# wrap to simulate a "long" db access
old_getBuildRequests = self.master.db.buildrequests.getBuildRequests
def longGetBuildRequests(*args, **kwargs):
res_d = old_getBuildRequests(*args, **kwargs)
long_d = defer.Deferred()
long_d.addCallback(lambda _: res_d)
self.reactor.callLater(0, long_d.callback, None)
return long_d
self.master.db.buildrequests.getBuildRequests = longGetBuildRequests
rows = [
*self.base_rows,
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows, exp_claims=[10], exp_builds=[('test-worker1', [10])]
)
@defer.inlineCallbacks
def test_limited_by_canStartBuild(self):
"""Set the 'canStartBuild' value in the config to something
that limits the possible options."""
self.bldr.config.nextWorker = nth_worker(-1)
pairs_tested = []
def _canStartBuild(worker, breq):
result = (worker.name, breq.id)
pairs_tested.append(result)
allowed = [
("test-worker1", 10),
("test-worker3", 11),
]
return result in allowed
self.bldr.config.canStartBuild = _canStartBuild
self.addWorkers({'test-worker1': 1, 'test-worker2': 1, 'test-worker3': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
fakedb.BuildRequest(id=12, buildsetid=11, builderid=77, submitted_at=140000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows,
exp_claims=[10, 11],
exp_builds=[('test-worker1', [10]), ('test-worker3', [11])],
)
# we expect brids in order (10-11-12),
# with each searched in reverse order of workers (3-2-1) available (due
# to nth_worker(-1))
self.assertEqual(
pairs_tested,
[
('test-worker3', 10),
('test-worker2', 10),
('test-worker1', 10),
('test-worker3', 11),
('test-worker2', 12),
],
)
@defer.inlineCallbacks
def test_limited_by_canStartBuild_deferreds(self):
# Another variant that returns Deferred types,
self.bldr.config.nextWorker = nth_worker(-1)
pairs_tested = []
def _canStartBuild(worker, breq):
result = (worker.name, breq.id)
pairs_tested.append(result)
allowed = [
("test-worker1", 10),
("test-worker3", 11),
]
return defer.succeed(result in allowed)
self.bldr.config.canStartBuild = _canStartBuild
self.addWorkers({'test-worker1': 1, 'test-worker2': 1, 'test-worker3': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
fakedb.BuildRequest(id=12, buildsetid=11, builderid=77, submitted_at=140000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows,
exp_claims=[10, 11],
exp_builds=[('test-worker1', [10]), ('test-worker3', [11])],
)
# we expect brids in order (10-11-12),
# with worker2 unable to pair
self.assertEqual(
pairs_tested,
[
('test-worker3', 10),
('test-worker2', 10),
('test-worker1', 10),
('test-worker3', 11),
('test-worker2', 12),
],
)
@defer.inlineCallbacks
def test_unlimited(self):
self.bldr.config.nextWorker = nth_worker(-1)
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows,
exp_claims=[10, 11],
exp_builds=[('test-worker2', [10]), ('test-worker1', [11])],
)
@defer.inlineCallbacks
def test_bldr_maybeStartBuild_fails_always(self):
self.bldr.config.nextWorker = nth_worker(-1)
# the builder fails to start the build; we'll see that the build
# was requested, but the brids will get claimed again
def maybeStartBuild(worker, builds):
self.startedBuilds.append((worker.name, builds))
return defer.succeed(False)
self.bldr.maybeStartBuild = maybeStartBuild
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows,
# claimed again so none taken!
exp_claims=[],
exp_builds=[('test-worker2', [10]), ('test-worker1', [11])],
)
@async_to_deferred
async def test_bldr_maybeStartBuild_fails_once(self):
self.bldr.config.nextWorker = nth_worker(-1)
# the builder fails to start the build; we'll see that the build
# was requested, but the brids will get claimed again
start_build_results = [False, True, True]
def maybeStartBuild(worker, builds):
self.startedBuilds.append((worker.name, builds))
return defer.succeed(start_build_results.pop(0))
self.bldr.maybeStartBuild = maybeStartBuild
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(id=10, buildsetid=11, builderid=77, submitted_at=130000),
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
]
await self.master.db.insert_test_data(rows)
# first time around, only #11 stays claimed
await self.brd._maybeStartBuildsOnBuilder(self.bldr)
self.assertMyClaims([11]) # claimed again so none taken!
self.assertBuildsStarted([('test-worker2', [10]), ('test-worker1', [11])])
# second time around the #10 will pass, adding another request and it
# is claimed
await self.brd._maybeStartBuildsOnBuilder(self.bldr)
self.assertMyClaims([10, 11])
self.assertBuildsStarted([
('test-worker2', [10]),
('test-worker1', [11]),
('test-worker2', [10]),
])
@defer.inlineCallbacks
def test_limited_by_requests(self):
self.bldr.config.nextWorker = nth_worker(1)
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [*self.base_rows, fakedb.BuildRequest(id=11, buildsetid=11, builderid=77)]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows, exp_claims=[11], exp_builds=[('test-worker2', [11])]
)
@defer.inlineCallbacks
def test_nextWorker_None(self):
self.bldr.config.nextWorker = lambda _1, _2, _3: defer.succeed(None)
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [*self.base_rows, fakedb.BuildRequest(id=11, buildsetid=11, builderid=77)]
yield self.do_test_maybeStartBuildsOnBuilder(rows=rows, exp_claims=[], exp_builds=[])
@defer.inlineCallbacks
def test_nextWorker_bogus(self):
self.bldr.config.nextWorker = lambda _1, _2, _3: defer.succeed(mock.Mock())
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [*self.base_rows, fakedb.BuildRequest(id=11, buildsetid=11, builderid=77)]
yield self.do_test_maybeStartBuildsOnBuilder(rows=rows, exp_claims=[], exp_builds=[])
@defer.inlineCallbacks
def test_nextBuild_None(self):
self.bldr.config.nextBuild = lambda _1, _2: defer.succeed(None)
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [*self.base_rows, fakedb.BuildRequest(id=11, buildsetid=11, builderid=77)]
yield self.do_test_maybeStartBuildsOnBuilder(rows=rows, exp_claims=[], exp_builds=[])
@defer.inlineCallbacks
def test_nextBuild_bogus(self):
self.bldr.config.nextBuild = lambda _1, _2: mock.Mock()
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [*self.base_rows, fakedb.BuildRequest(id=11, buildsetid=11, builderid=77)]
yield self.do_test_maybeStartBuildsOnBuilder(rows=rows, exp_claims=[], exp_builds=[])
@defer.inlineCallbacks
def test_nextBuild_fails(self):
def nextBuildRaises(*args):
raise RuntimeError("xx")
self.bldr.config.nextBuild = nextBuildRaises
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [*self.base_rows, fakedb.BuildRequest(id=11, buildsetid=11, builderid=77)]
result = self.do_test_maybeStartBuildsOnBuilder(rows=rows, exp_claims=[], exp_builds=[])
self.assertEqual(1, len(self.flushLoggedErrors(RuntimeError)))
yield result
# check concurrency edge cases
@defer.inlineCallbacks
def test_claim_race(self):
self.bldr.config.nextWorker = nth_worker(0)
# fake a race condition on the buildrequests table
old_claimBuildRequests = self.master.db.buildrequests.claimBuildRequests
def claimBuildRequests(brids, claimed_at=None):
# first, ensure this only happens the first time
self.master.db.buildrequests.claimBuildRequests = old_claimBuildRequests
# claim brid 10 for some other master
assert 10 in brids
self.master.db.buildrequests._claim_buildrequests_for_master(
[10], 136000, 9999
) # some other masterid
# ..and fail
return defer.fail(buildrequests.AlreadyClaimedError())
self.master.db.buildrequests.claimBuildRequests = claimBuildRequests
self.addWorkers({'test-worker1': 1, 'test-worker2': 1})
rows = [
*self.base_rows,
fakedb.BuildRequest(
id=10, buildsetid=11, builderid=77, submitted_at=130000
), # will turn out to be claimed!
fakedb.BuildRequest(id=11, buildsetid=11, builderid=77, submitted_at=135000),
]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows, exp_claims=[11], exp_builds=[('test-worker1', [11])]
)
# nextWorker
@defer.inlineCallbacks
def do_test_nextWorker(self, nextWorker, global_select_next_worker, exp_choice=None):
if global_select_next_worker:
self.master.config.select_next_worker = nextWorker
builder_config = config.BuilderConfig(
name='bldrconf',
workernames=['wk1', 'wk2'],
builddir='bdir',
factory=factory.BuildFactory(),
)
else:
builder_config = config.BuilderConfig(
name='bldrconf',
workernames=['wk1', 'wk2'],
builddir='bdir',
factory=factory.BuildFactory(),
nextWorker=nextWorker,
)
self.bldr = yield self.createBuilder('B', builderid=78, builder_config=builder_config)
for i in range(4):
self.addWorkers({f'test-worker{i}': 1})
rows = [
fakedb.SourceStamp(id=21),
fakedb.Builder(id=78, name='B'),
fakedb.Buildset(id=12, reason='because'),
fakedb.BuildsetSourceStamp(sourcestampid=21, buildsetid=12),
fakedb.BuildRequest(id=12, buildsetid=12, builderid=78),
]
if exp_choice is None:
exp_claims = []
exp_builds = []
else:
exp_claims = [12]
exp_builds = [(f'test-worker{exp_choice}', [12])]
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows, exp_claims=exp_claims, exp_builds=exp_builds
)
@parameterized.expand([True, False])
def test_nextWorker_gets_buildrequest(self, global_select_next_worker):
def nextWorker(bldr, lst, br=None):
self.assertNotEqual(br, None)
return self.do_test_nextWorker(
nextWorker, global_select_next_worker=global_select_next_worker
)
@parameterized.expand([True, False])
def test_nextWorker_default(self, global_select_next_worker):
self.patch(random, 'choice', nth_worker(2))
return self.do_test_nextWorker(
None, exp_choice=2, global_select_next_worker=global_select_next_worker
)
@parameterized.expand([True, False])
def test_nextWorker_simple(self, global_select_next_worker):
def nextWorker(bldr, lst, br=None):
self.assertIdentical(bldr, self.bldr)
return lst[1]
return self.do_test_nextWorker(
nextWorker, global_select_next_worker=global_select_next_worker, exp_choice=1
)
@parameterized.expand([True, False])
def test_nextWorker_deferred(self, global_select_next_worker):
def nextWorker(bldr, lst, br=None):
self.assertIdentical(bldr, self.bldr)
return defer.succeed(lst[1])
return self.do_test_nextWorker(
nextWorker, global_select_next_worker=global_select_next_worker, exp_choice=1
)
@parameterized.expand([True, False])
@defer.inlineCallbacks
def test_nextWorker_exception(self, global_select_next_worker):
def nextWorker(bldr, lst, br=None):
raise RuntimeError("")
yield self.do_test_nextWorker(
nextWorker, global_select_next_worker=global_select_next_worker
)
self.assertEqual(1, len(self.flushLoggedErrors(RuntimeError)))
@parameterized.expand([True, False])
@defer.inlineCallbacks
def test_nextWorker_failure(self, global_select_next_worker):
def nextWorker(bldr, lst, br=None):
return defer.fail(failure.Failure(RuntimeError()))
yield self.do_test_nextWorker(
nextWorker, global_select_next_worker=global_select_next_worker
)
self.assertEqual(1, len(self.flushLoggedErrors(RuntimeError)))
# _nextBuild
@defer.inlineCallbacks
def do_test_nextBuild(self, nextBuild, exp_choice=None):
self.bldr.config.nextWorker = nth_worker(-1)
self.bldr.config.nextBuild = nextBuild
rows = self.make_workers(4)
exp_claims = []
exp_builds = []
if exp_choice is not None:
worker = 3
for choice in exp_choice:
exp_claims.append(choice)
exp_builds.append((f'test-worker{worker}', [choice]))
worker = worker - 1
yield self.do_test_maybeStartBuildsOnBuilder(
rows=rows, exp_claims=sorted(exp_claims), exp_builds=exp_builds
)
def test_nextBuild_default(self):
"default chooses the first in the list, which should be the earliest"
return self.do_test_nextBuild(None, exp_choice=[10, 11, 12, 13])
def test_nextBuild_simple(self):
def nextBuild(bldr, lst):
self.assertIdentical(bldr, self.bldr)
return lst[-1]
return self.do_test_nextBuild(nextBuild, exp_choice=[13, 12, 11, 10])
def test_nextBuild_deferred(self):
def nextBuild(bldr, lst):
self.assertIdentical(bldr, self.bldr)
return defer.succeed(lst[-1])
return self.do_test_nextBuild(nextBuild, exp_choice=[13, 12, 11, 10])
def test_nextBuild_exception(self):
def nextBuild(bldr, lst):
raise RuntimeError("")
result = self.do_test_nextBuild(nextBuild)
self.assertEqual(1, len(self.flushLoggedErrors(RuntimeError)))
return result
def test_nextBuild_failure(self):
def nextBuild(bldr, lst):
return defer.fail(failure.Failure(RuntimeError()))
result = self.do_test_nextBuild(nextBuild)
self.assertEqual(1, len(self.flushLoggedErrors(RuntimeError)))
return result
| 34,454 | Python | .py | 747 | 36.350736 | 100 | 0.636635 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,441 | test_buildrequest.py | buildbot_buildbot/master/buildbot/test/unit/process/test_buildrequest.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import datetime
import json
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process import buildrequest
from buildbot.process.builder import Builder
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
class TestBuildRequestCollapser(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield 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)
@defer.inlineCallbacks
def createBuilder(self, name, builderid=None):
if builderid is None:
b = fakedb.Builder(name=name)
yield self.master.db.insert_test_data([b])
builderid = b.id
bldr = mock.Mock(name=name)
bldr.name = name
bldr.master = self.master
self.master.botmaster.builders[name] = bldr
self.builders[name] = bldr
bldr.getCollapseRequestsFn = lambda: False
return bldr
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def do_request_collapse(self, brids, exp):
brCollapser = buildrequest.BuildRequestCollapser(self.master, brids)
self.assertEqual(exp, sorted((yield brCollapser.collapse())))
@defer.inlineCallbacks
def test_collapseRequests_no_other_request(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# Allow all requests
self.fail("Should never be called")
# pylint: disable=unreachable
return True
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
rows = [
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, revision='r234', repository='repo', codebase='A'),
fakedb.Change(changeid=14, codebase='A', sourcestampid=234),
fakedb.Buildset(id=30, reason='foo', submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.BuildRequest(
id=19, buildsetid=30, builderid=77, priority=13, submitted_at=1300305712, results=-1
),
]
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([19], [])
BASE_ROWS = [
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, revision=None, repository='repo', codebase='C'),
fakedb.Buildset(id=30, reason='foo', submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.Buildset(id=31, reason='foo', submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=31),
fakedb.Buildset(id=32, reason='foo', submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=32),
fakedb.BuildRequest(
id=19, buildsetid=30, builderid=77, priority=13, submitted_at=1300305712, results=-1
),
fakedb.BuildRequest(
id=20, buildsetid=31, builderid=77, priority=13, submitted_at=1300305712, results=-1
),
fakedb.BuildRequest(
id=21, buildsetid=32, builderid=77, priority=13, submitted_at=1300305712, results=-1
),
]
@defer.inlineCallbacks
def test_collapseRequests_no_collapse(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# Fail all collapse attempts
return False
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
yield self.master.db.insert_test_data(self.BASE_ROWS)
yield self.do_request_collapse([21], [])
@defer.inlineCallbacks
def test_collapseRequests_collapse_all(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# collapse all attempts
return True
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
yield self.master.db.insert_test_data(self.BASE_ROWS)
yield self.do_request_collapse([21], [19, 20])
@defer.inlineCallbacks
def test_collapseRequests_collapse_all_duplicates(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# collapse all attempts
return True
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
yield self.master.db.insert_test_data(self.BASE_ROWS)
yield self.do_request_collapse([21, 21], [19, 20])
# As documented:
# Sourcestamps are compatible if all of the below conditions are met:
#
# * Their codebase, branch, project, and repository attributes match exactly
# * Neither source stamp has a patch (e.g., from a try scheduler)
# * Either both source stamps are associated with changes, or neither are associated with
# changes but they have matching revisions.
def makeBuildRequestRows(
self,
brid,
bsid,
changeid,
ssid,
patchid=None,
bs_properties=None,
):
rows = [
fakedb.Buildset(id=bsid, reason='foo', submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=ssid, buildsetid=bsid),
fakedb.BuildRequest(
id=brid,
buildsetid=bsid,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1,
),
]
if changeid:
rows.append(
fakedb.Change(
changeid=changeid,
branch='trunk',
revision='9283',
repository='svn://...',
project='world-domination',
sourcestampid=ssid,
)
)
if patchid:
rows.append(
fakedb.Patch(
id=patchid,
patch_base64='aGVsbG8sIHdvcmxk',
patch_author='bar',
patch_comment='foo',
subdir='/foo',
patchlevel=3,
)
)
if bs_properties:
for prop_name, prop_value in bs_properties.items():
rows.append(
fakedb.BuildsetProperty(
buildsetid=bsid,
property_name=prop_name,
property_value=json.dumps(prop_value),
),
)
return rows
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_codebases(self):
rows = [
fakedb.SourceStamp(id=222, codebase='A'),
fakedb.SourceStamp(id=223, codebase='C'),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222)
rows += self.makeBuildRequestRows(21, 121, None, 223)
rows += self.makeBuildRequestRows(19, 119, None, 223)
rows += self.makeBuildRequestRows(20, 120, None, 223)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([22], [])
yield self.do_request_collapse([21], [19, 20])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_does_not_collapse_older(self):
rows = [
fakedb.SourceStamp(id=222),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(21, 121, None, 222)
rows += self.makeBuildRequestRows(19, 119, None, 222)
rows += self.makeBuildRequestRows(20, 120, None, 222)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([19], [])
yield self.do_request_collapse([20], [19])
yield self.do_request_collapse([21], [20])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_does_not_collapse_concurrent_claims(self):
rows = [
fakedb.SourceStamp(id=222),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(21, 121, None, 222)
rows += self.makeBuildRequestRows(19, 119, None, 222)
rows += self.makeBuildRequestRows(20, 120, None, 222)
claimed = []
@defer.inlineCallbacks
def collapse_fn(master, builder, brdict1, brdict2):
if not claimed:
yield self.master.data.updates.claimBuildRequests([20])
claimed.append(20)
res = yield Builder._defaultCollapseRequestFn(master, builder, brdict1, brdict2)
return res
self.bldr.getCollapseRequestsFn = lambda: collapse_fn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([21], [19])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_does_not_collapse_scheduler_props(self):
rows = [
fakedb.SourceStamp(id=222),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(
21, 121, None, 222, bs_properties={'prop': ('value', 'Scheduler')}
)
rows += self.makeBuildRequestRows(
20, 120, None, 222, bs_properties={'prop': ('value', 'Other source')}
)
rows += self.makeBuildRequestRows(
19, 119, None, 222, bs_properties={'prop': ('value2', 'Scheduler')}
)
rows += self.makeBuildRequestRows(
18, 118, None, 222, bs_properties={'prop': ('value', 'Scheduler')}
)
rows += self.makeBuildRequestRows(
17, 117, None, 222, bs_properties={'prop': ('value3', 'Other source')}
)
rows += self.makeBuildRequestRows(16, 116, None, 222)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
# only the same property coming from a scheduler is matched
yield self.do_request_collapse([21], [18])
# only takes into account properties coming from scheduler
yield self.do_request_collapse([20], [16, 17])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_codebases_branches(self):
rows = [
fakedb.SourceStamp(id=222, codebase='A', branch='br1'),
fakedb.SourceStamp(id=223, codebase='C', branch='br2'),
fakedb.SourceStamp(id=224, codebase='C', branch='br3'),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222)
rows += self.makeBuildRequestRows(21, 121, None, 223)
rows += self.makeBuildRequestRows(19, 119, None, 223)
rows += self.makeBuildRequestRows(20, 120, None, 224)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([22], [])
yield self.do_request_collapse([21], [19])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_codebases_repository(self):
rows = [
fakedb.SourceStamp(id=222, codebase='A', repository='repo1'),
fakedb.SourceStamp(id=223, codebase='C', repository='repo2'),
fakedb.SourceStamp(id=224, codebase='C', repository='repo3'),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222)
rows += self.makeBuildRequestRows(21, 121, None, 223)
rows += self.makeBuildRequestRows(19, 119, None, 223)
rows += self.makeBuildRequestRows(20, 120, None, 224)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([22], [])
yield self.do_request_collapse([21], [19])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_codebases_projects(self):
rows = [
fakedb.SourceStamp(id=222, codebase='A', project='proj1'),
fakedb.SourceStamp(id=223, codebase='C', project='proj2'),
fakedb.SourceStamp(id=224, codebase='C', project='proj3'),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222)
rows += self.makeBuildRequestRows(21, 121, None, 223)
rows += self.makeBuildRequestRows(19, 119, None, 223)
rows += self.makeBuildRequestRows(20, 120, None, 224)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([22], [])
yield self.do_request_collapse([21], [19])
# * Neither source stamp has a patch (e.g., from a try scheduler)
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_a_patch(self):
rows = [
fakedb.SourceStamp(id=222, codebase='A'),
fakedb.SourceStamp(id=223, codebase='C'),
fakedb.SourceStamp(id=224, codebase='C', patchid=123),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222)
rows += self.makeBuildRequestRows(21, 121, None, 223)
rows += self.makeBuildRequestRows(19, 119, None, 224)
rows += self.makeBuildRequestRows(20, 120, None, 223)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([22], [])
yield self.do_request_collapse([21], [20])
# * Either both source stamps are associated with changes..
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_changes(self):
rows = [
fakedb.SourceStamp(id=222, codebase='A'),
fakedb.SourceStamp(id=223, codebase='C'),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222)
rows += self.makeBuildRequestRows(21, 121, 123, 223)
rows += self.makeBuildRequestRows(19, 119, None, 223)
rows += self.makeBuildRequestRows(20, 120, 124, 223)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([22], [])
yield self.do_request_collapse([21], [19, 20])
# * ... or neither are associated with changes but they have matching revisions.
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_non_matching_revision(self):
rows = [
fakedb.SourceStamp(id=222, codebase='A'),
fakedb.SourceStamp(id=223, codebase='C'),
fakedb.SourceStamp(id=224, codebase='C', revision='abcd1234'),
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222)
rows += self.makeBuildRequestRows(21, 121, None, 223)
rows += self.makeBuildRequestRows(19, 119, None, 224)
rows += self.makeBuildRequestRows(20, 120, None, 223)
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.master.db.insert_test_data(rows)
yield self.do_request_collapse([22], [])
yield self.do_request_collapse([21], [20])
class TestSourceStamp(unittest.TestCase):
def test_asdict_minimal(self):
ssdatadict = {
'ssid': '123',
'branch': None,
'revision': None,
'patch': None,
'repository': 'testrepo',
'codebase': 'testcodebase',
'project': 'testproject',
'created_at': datetime.datetime(2019, 4, 1, 23, 38, 33, 154354),
}
ss = buildrequest.TempSourceStamp(ssdatadict)
self.assertEqual(
ss.asDict(),
{
'branch': None,
'codebase': 'testcodebase',
'patch_author': None,
'patch_body': None,
'patch_comment': None,
'patch_level': None,
'patch_subdir': None,
'project': 'testproject',
'repository': 'testrepo',
'revision': None,
},
)
def test_asdict_no_patch(self):
ssdatadict = {
'ssid': '123',
'branch': 'testbranch',
'revision': 'testrev',
'patch': None,
'repository': 'testrepo',
'codebase': 'testcodebase',
'project': 'testproject',
'created_at': datetime.datetime(2019, 4, 1, 23, 38, 33, 154354),
}
ss = buildrequest.TempSourceStamp(ssdatadict)
self.assertEqual(
ss.asDict(),
{
'branch': 'testbranch',
'codebase': 'testcodebase',
'patch_author': None,
'patch_body': None,
'patch_comment': None,
'patch_level': None,
'patch_subdir': None,
'project': 'testproject',
'repository': 'testrepo',
'revision': 'testrev',
},
)
def test_asdict_with_patch(self):
ssdatadict = {
'ssid': '123',
'branch': 'testbranch',
'revision': 'testrev',
'patch': {
'patchid': 1234,
'body': b'testbody',
'level': 2,
'author': 'testauthor',
'comment': 'testcomment',
'subdir': 'testsubdir',
},
'repository': 'testrepo',
'codebase': 'testcodebase',
'project': 'testproject',
'created_at': datetime.datetime(2019, 4, 1, 23, 38, 33, 154354),
}
ss = buildrequest.TempSourceStamp(ssdatadict)
self.assertEqual(
ss.asDict(),
{
'branch': 'testbranch',
'codebase': 'testcodebase',
'patch_author': 'testauthor',
'patch_body': b'testbody',
'patch_comment': 'testcomment',
'patch_level': 2,
'patch_subdir': 'testsubdir',
'project': 'testproject',
'repository': 'testrepo',
'revision': 'testrev',
},
)
class TestBuildRequest(TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_fromBrdict(self):
master = yield fakemaster.make_master(self, wantData=True, wantDb=True)
yield master.db.insert_test_data([
fakedb.Builder(id=77, name='bldr'),
fakedb.SourceStamp(
id=234,
branch='trunk',
revision='9284',
repository='svn://...',
project='world-domination',
),
fakedb.Change(
changeid=13,
branch='trunk',
revision='9283',
repository='svn://...',
project='world-domination',
sourcestampid=234,
),
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
brdict = yield master.db.buildrequests.getBuildRequest(288)
br = yield buildrequest.BuildRequest.fromBrdict(master, brdict)
# check enough of the source stamp to verify it found the changes
self.assertEqual([ss.ssid for ss in br.sources.values()], [234])
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)
@defer.inlineCallbacks
def test_fromBrdict_no_sourcestamps(self):
master = yield fakemaster.make_master(self, wantData=True, wantDb=True)
yield master.db.insert_test_data([
fakedb.Builder(id=78, name='not important'),
fakedb.Buildset(id=539, reason='triggered'),
# buildset has no sourcestamps
fakedb.BuildRequest(id=288, buildsetid=539, builderid=78, priority=0),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
brdict = yield master.db.buildrequests.getBuildRequest(288)
with self.assertRaises(AssertionError):
yield buildrequest.BuildRequest.fromBrdict(master, brdict)
@defer.inlineCallbacks
def test_fromBrdict_multiple_sourcestamps(self):
master = yield fakemaster.make_master(self, wantData=True, wantDb=True)
yield master.db.insert_test_data([
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
brdict = yield master.db.buildrequests.getBuildRequest(288)
br = yield buildrequest.BuildRequest.fromBrdict(master, brdict)
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)
@defer.inlineCallbacks
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 = yield fakemaster.make_master(self, wantData=True, wantDb=True)
yield master.db.insert_test_data([
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
brdict = yield master.db.buildrequests.getBuildRequest(288)
res = yield buildrequest.BuildRequest.fromBrdict(master, brdict)
brs.append(res)
brdict = yield master.db.buildrequests.getBuildRequest(289)
res = yield buildrequest.BuildRequest.fromBrdict(master, brdict)
brs.append(res)
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')
@defer.inlineCallbacks
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 performed and raises error:
Merging requests requires both requests to have the same codebases
"""
master = yield fakemaster.make_master(self, wantData=True, wantDb=True)
yield master.db.insert_test_data([
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),
])
old_br = yield master.data.get(('buildrequests', 288))
new_br = yield master.data.get(('buildrequests', 289))
can_collapse = yield buildrequest.BuildRequest.canBeCollapsed(master, new_br, old_br)
self.assertEqual(can_collapse, False)
| 32,063 | Python | .py | 734 | 32.121253 | 100 | 0.58235 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,442 | test_botmaster_BotMaster.py | buildbot_buildbot/master/buildbot/test/unit/process/test_botmaster_BotMaster.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process import factory
from buildbot.process.botmaster import BotMaster
from buildbot.process.results import CANCELLED
from buildbot.process.results import RETRY
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
class TestCleanShutdown(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True)
self.botmaster = BotMaster()
yield self.botmaster.setServiceParent(self.master)
self.botmaster.startService()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def assertReactorStopped(self, _=None):
self.assertTrue(self.reactor.stop_called)
def assertReactorNotStopped(self, _=None):
self.assertFalse(self.reactor.stop_called)
def makeFakeBuild(self, waitedFor=False):
self.fake_builder = builder = mock.Mock()
self.build_deferred = defer.Deferred()
request = mock.Mock()
request.waitedFor = waitedFor
build = mock.Mock()
build.stopBuild = self.stopFakeBuild
build.waitUntilFinished.return_value = self.build_deferred
build.requests = [request]
builder.building = [build]
self.botmaster.builders = mock.Mock()
self.botmaster.builders.values.return_value = [builder]
def stopFakeBuild(self, reason, results):
self.reason = reason
self.results = results
self.finishFakeBuild()
return defer.succeed(None)
def finishFakeBuild(self):
self.fake_builder.building = []
self.build_deferred.callback(None)
# tests
def test_shutdown_idle(self):
"""Test that the master shuts down when it's idle"""
self.botmaster.cleanShutdown()
self.assertReactorStopped()
def test_shutdown_busy(self):
"""Test that the master shuts down after builds finish"""
self.makeFakeBuild()
self.botmaster.cleanShutdown()
# check that we haven't stopped yet, since there's a running build
self.assertReactorNotStopped()
# try to shut it down again, just to check that this does not fail
self.botmaster.cleanShutdown()
# Now we cause the build to finish
self.finishFakeBuild()
# And now we should be stopped
self.assertReactorStopped()
def test_shutdown_busy_quick(self):
"""Test that the master shuts down after builds finish"""
self.makeFakeBuild()
self.botmaster.cleanShutdown(quickMode=True)
# And now we should be stopped
self.assertReactorStopped()
self.assertEqual(self.results, RETRY)
def test_shutdown_busy_quick_cancelled(self):
"""Test that the master shuts down after builds finish"""
self.makeFakeBuild(waitedFor=True)
self.botmaster.cleanShutdown(quickMode=True)
# And now we should be stopped
self.assertReactorStopped()
self.assertEqual(self.results, CANCELLED)
def test_shutdown_cancel_not_shutting_down(self):
"""Test that calling cancelCleanShutdown when none is in progress
works"""
# this just shouldn't fail..
self.botmaster.cancelCleanShutdown()
def test_shutdown_cancel(self):
"""Test that we can cancel a shutdown"""
self.makeFakeBuild()
self.botmaster.cleanShutdown()
# Next we check that we haven't stopped yet, since there's a running
# build.
self.assertReactorNotStopped()
# the BuildRequestDistributor is still running
# distributing child BuildRequests blocking
# parent Build from finishing
self.assertTrue(self.botmaster.brd.running)
self.assertTrue(self.botmaster.brd.distribute_only_waited_childs)
# Cancel the shutdown
self.botmaster.cancelCleanShutdown()
# Now we cause the build to finish
self.finishFakeBuild()
# We should still be running!
self.assertReactorNotStopped()
# and the BuildRequestDistributor should be, as well
# no longer limiting builds to those with parents
self.assertTrue(self.botmaster.brd.running)
self.assertFalse(self.botmaster.brd.distribute_only_waited_childs)
class TestBotMaster(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantMq=True, wantData=True)
self.master.mq = self.master.mq
self.master.botmaster.disownServiceParent()
self.botmaster = BotMaster()
yield self.botmaster.setServiceParent(self.master)
self.new_config = mock.Mock()
self.botmaster.startService()
@defer.inlineCallbacks
def tearDown(self):
yield self.botmaster.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_reconfigServiceWithBuildbotConfig(self):
# check that reconfigServiceBuilders is called.
self.patch(
self.botmaster, 'reconfigProjects', mock.Mock(side_effect=lambda c: defer.succeed(None))
)
self.patch(
self.botmaster,
'reconfigServiceBuilders',
mock.Mock(side_effect=lambda c: defer.succeed(None)),
)
self.patch(self.botmaster, 'maybeStartBuildsForAllBuilders', mock.Mock())
new_config = mock.Mock()
yield self.botmaster.reconfigServiceWithBuildbotConfig(new_config)
self.botmaster.reconfigServiceBuilders.assert_called_with(new_config)
self.botmaster.reconfigProjects.assert_called_with(new_config)
self.assertTrue(self.botmaster.maybeStartBuildsForAllBuilders.called)
@defer.inlineCallbacks
def test_reconfigServiceBuilders_add_remove(self):
bc = config.BuilderConfig(name='bldr', factory=factory.BuildFactory(), workername='f')
self.new_config.builders = [bc]
yield self.botmaster.reconfigServiceBuilders(self.new_config)
bldr = self.botmaster.builders['bldr']
self.assertIdentical(bldr.parent, self.botmaster)
self.assertIdentical(bldr.master, self.master)
self.assertEqual(self.botmaster.builderNames, ['bldr'])
self.new_config.builders = []
yield self.botmaster.reconfigServiceBuilders(self.new_config)
self.assertIdentical(bldr.parent, None)
self.assertIdentical(bldr.master, None)
self.assertEqual(self.botmaster.builders, {})
self.assertEqual(self.botmaster.builderNames, [])
def test_maybeStartBuildsForBuilder(self):
brd = self.botmaster.brd = mock.Mock()
self.botmaster.maybeStartBuildsForBuilder('frank')
brd.maybeStartBuildsOn.assert_called_once_with(['frank'])
def test_maybeStartBuildsForWorker(self):
brd = self.botmaster.brd = mock.Mock()
b1 = mock.Mock(name='frank')
b1.name = 'frank'
b2 = mock.Mock(name='larry')
b2.name = 'larry'
self.botmaster.getBuildersForWorker = mock.Mock(return_value=[b1, b2])
self.botmaster.maybeStartBuildsForWorker('centos')
self.botmaster.getBuildersForWorker.assert_called_once_with('centos')
brd.maybeStartBuildsOn.assert_called_once_with(['frank', 'larry'])
def test_maybeStartBuildsForAll(self):
brd = self.botmaster.brd = mock.Mock()
self.botmaster.builderNames = ['frank', 'larry']
self.botmaster.maybeStartBuildsForAllBuilders()
brd.maybeStartBuildsOn.assert_called_once_with(['frank', 'larry'])
| 8,587 | Python | .py | 183 | 39.251366 | 100 | 0.707799 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,443 | test_remotetransfer.py | buildbot_buildbot/master/buildbot/test/unit/process/test_remotetransfer.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import os
import stat
import tempfile
from unittest.mock import Mock
from twisted.trial import unittest
from buildbot.process import remotetransfer
# Test buildbot.steps.remotetransfer.FileWriter class.
class TestFileWriter(unittest.TestCase):
# test FileWriter.__init__() method.
def testInit(self):
#
# patch functions called in constructor
#
# patch os.path.exists() to always return False
mockedExists = Mock(return_value=False)
self.patch(os.path, "exists", mockedExists)
# capture calls to os.makedirs()
mockedMakedirs = Mock()
self.patch(os, 'makedirs', mockedMakedirs)
# capture calls to tempfile.mkstemp()
mockedMkstemp = Mock(return_value=(7, "tmpname"))
self.patch(tempfile, "mkstemp", mockedMkstemp)
# capture calls to os.fdopen()
mockedFdopen = Mock()
self.patch(os, "fdopen", mockedFdopen)
#
# call _FileWriter constructor
#
destfile = os.path.join("dir", "file")
remotetransfer.FileWriter(destfile, 64, stat.S_IRUSR)
#
# validate captured calls
#
absdir = os.path.dirname(os.path.abspath(os.path.join("dir", "file")))
mockedExists.assert_called_once_with(absdir)
mockedMakedirs.assert_called_once_with(absdir)
mockedMkstemp.assert_called_once_with(dir=absdir, prefix='buildbot-transfer-')
mockedFdopen.assert_called_once_with(7, 'wb')
class TestStringFileWriter(unittest.TestCase):
def testBasic(self):
sfw = remotetransfer.StringFileWriter()
# StringFileWriter takes bytes or native string and outputs native strings
sfw.remote_write(b'bytes')
sfw.remote_write(' or str')
self.assertEqual(sfw.buffer, 'bytes or str')
| 2,529 | Python | .py | 59 | 36.932203 | 86 | 0.707536 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,444 | test_remotecommand.py | buildbot_buildbot/master/buildbot/test/unit/process/test_remotecommand.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.trial import unittest
from buildbot.process import remotecommand
from buildbot.test.fake import logfile
from buildbot.test.util import interfaces
from buildbot.test.util.warnings import assertNotProducesWarnings
from buildbot.warnings import DeprecatedApiWarning
class TestRemoteShellCommand(unittest.TestCase):
def test_obfuscated_arguments(self):
command = [
"echo",
("obfuscated", "real", "fake"),
"test",
("obfuscated", "real2", "fake2"),
("not obfuscated", "a", "b"),
("obfuscated"), # not obfuscated
("obfuscated", "test"), # not obfuscated
("obfuscated", "1", "2", "3"), # not obfuscated)
]
cmd = remotecommand.RemoteShellCommand("build", command)
self.assertEqual(cmd.command, command)
self.assertEqual(
cmd.fake_command,
[
"echo",
"fake",
"test",
"fake2",
("not obfuscated", "a", "b"),
("obfuscated"), # not obfuscated
# not obfuscated
("obfuscated", "test"),
# not obfuscated)
("obfuscated", "1", "2", "3"),
],
)
def test_not_obfuscated_arguments(self):
command = "echo test"
cmd = remotecommand.RemoteShellCommand("build", command)
self.assertEqual(cmd.command, command)
self.assertEqual(cmd.fake_command, command)
# NOTE:
#
# This interface is considered private to Buildbot and may change without
# warning in future versions.
class Tests(interfaces.InterfaceTests, unittest.TestCase):
def makeRemoteCommand(self, stdioLogName='stdio'):
return remotecommand.RemoteCommand('ping', {'arg': 'val'}, stdioLogName=stdioLogName)
def test_signature_RemoteCommand_constructor(self):
@self.assertArgSpecMatches(remotecommand.RemoteCommand.__init__)
def __init__(
self,
remote_command,
args,
ignore_updates=False,
collectStdout=False,
collectStderr=False,
decodeRC=None,
stdioLogName='stdio',
):
pass
def test_signature_RemoteShellCommand_constructor(self):
@self.assertArgSpecMatches(remotecommand.RemoteShellCommand.__init__)
def __init__(
self,
workdir,
command,
env=None,
want_stdout=1,
want_stderr=1,
timeout=20 * 60,
maxTime=None,
max_lines=None,
sigtermTime=None,
logfiles=None,
usePTY=None,
logEnviron=True,
collectStdout=False,
collectStderr=False,
interruptSignal=None,
initialStdin=None,
decodeRC=None,
stdioLogName='stdio',
):
pass
def test_signature_run(self):
cmd = self.makeRemoteCommand()
@self.assertArgSpecMatches(cmd.run)
def run(self, step, conn, builder_name):
pass
def test_signature_useLog(self):
cmd = self.makeRemoteCommand()
@self.assertArgSpecMatches(cmd.useLog)
def useLog(self, log_, closeWhenFinished=False, logfileName=None):
pass
def test_signature_useLogDelayed(self):
cmd = self.makeRemoteCommand()
@self.assertArgSpecMatches(cmd.useLogDelayed)
def useLogDelayed(self, logfileName, activateCallBack, closeWhenFinished=False):
pass
def test_signature_interrupt(self):
cmd = self.makeRemoteCommand()
@self.assertArgSpecMatches(cmd.interrupt)
def useLogDelayed(self, why):
pass
def test_signature_didFail(self):
cmd = self.makeRemoteCommand()
@self.assertArgSpecMatches(cmd.didFail)
def useLogDelayed(self):
pass
def test_signature_logs(self):
cmd = self.makeRemoteCommand()
self.assertIsInstance(cmd.logs, dict)
def test_signature_active(self):
cmd = self.makeRemoteCommand()
self.assertIsInstance(cmd.active, bool)
def test_RemoteShellCommand_constructor(self):
remotecommand.RemoteShellCommand('wkdir', 'some-command')
def test_notStdioLog(self):
logname = 'notstdio'
cmd = self.makeRemoteCommand(stdioLogName=logname)
log = logfile.FakeLogFile(logname)
cmd.useLog(log)
cmd.addStdout('some stdout')
self.assertEqual(log.stdout, 'some stdout')
cmd.addStderr('some stderr')
self.assertEqual(log.stderr, 'some stderr')
cmd.addHeader('some header')
self.assertEqual(log.header, 'some header')
def test_RemoteShellCommand_usePTY_on_worker_2_16(self):
cmd = remotecommand.RemoteShellCommand('workdir', 'shell')
def workerVersion(command, oldversion=None):
return '2.16'
def workerVersionIsOlderThan(command, minversion):
return ['2', '16'] < minversion.split('.')
step = mock.Mock()
step.workerVersionIsOlderThan = workerVersionIsOlderThan
step.workerVersion = workerVersion
conn = mock.Mock()
conn.remoteStartCommand = mock.Mock(return_value=None)
cmd.run(step, conn, 'builder')
self.assertEqual(cmd.args['usePTY'], 'slave-config')
class TestWorkerTransition(unittest.TestCase):
def test_RemoteShellCommand_usePTY(self):
with assertNotProducesWarnings(DeprecatedApiWarning):
cmd = remotecommand.RemoteShellCommand('workdir', 'command')
self.assertTrue(cmd.args['usePTY'] is None)
with assertNotProducesWarnings(DeprecatedApiWarning):
cmd = remotecommand.RemoteShellCommand('workdir', 'command', usePTY=True)
self.assertTrue(cmd.args['usePTY'])
with assertNotProducesWarnings(DeprecatedApiWarning):
cmd = remotecommand.RemoteShellCommand('workdir', 'command', usePTY=False)
self.assertFalse(cmd.args['usePTY'])
| 6,857 | Python | .py | 167 | 31.874251 | 93 | 0.644565 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,445 | test_cache.py | buildbot_buildbot/master/buildbot/test/unit/process/test_cache.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process import cache
class CacheManager(unittest.TestCase):
def setUp(self):
self.caches = cache.CacheManager()
def make_config(self, **kwargs):
cfg = mock.Mock()
cfg.caches = kwargs
return cfg
def test_get_cache_idempotency(self):
foo_cache = self.caches.get_cache("foo", None)
bar_cache = self.caches.get_cache("bar", None)
foo_cache2 = self.caches.get_cache("foo", None)
self.assertIdentical(foo_cache, foo_cache2)
self.assertNotIdentical(foo_cache, bar_cache)
@defer.inlineCallbacks
def test_reconfigServiceWithBuildbotConfig(self):
# load config with one cache loaded and the other not
foo_cache = self.caches.get_cache("foo", None)
yield self.caches.reconfigServiceWithBuildbotConfig(self.make_config(foo=5, bar=6, bing=11))
bar_cache = self.caches.get_cache("bar", None)
self.assertEqual((foo_cache.max_size, bar_cache.max_size), (5, 6))
def test_get_metrics(self):
self.caches.get_cache("foo", None)
self.assertIn('foo', self.caches.get_metrics())
metric = self.caches.get_metrics()['foo']
for k in 'hits', 'refhits', 'misses', 'max_size':
self.assertIn(k, metric)
| 2,078 | Python | .py | 44 | 41.909091 | 100 | 0.713933 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,446 | test_project.py | buildbot_buildbot/master/buildbot/test/unit/process/test_project.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.trial import unittest
from buildbot.process.project import Project
from buildbot.test.util.config import ConfigErrorsMixin
class ProjectConfigTests(ConfigErrorsMixin, unittest.TestCase):
def test_description_wrong_format(self):
with self.assertRaisesConfigError("project description format must be None"):
Project(name="a", description_format="unknown")
| 1,101 | Python | .py | 21 | 50.047619 | 85 | 0.793488 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,447 | test_buildstep.py | buildbot_buildbot/master/buildbot/test/unit/process/test_buildstep.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from parameterized import parameterized
from twisted.internet import defer
from twisted.internet import error
from twisted.internet.task import deferLater
from twisted.python import failure
from twisted.python import log
from twisted.trial import unittest
from buildbot import locks
from buildbot.config import ConfigErrors
from buildbot.interfaces import WorkerSetupError
from buildbot.plugins import util
from buildbot.process import buildstep
from buildbot.process import properties
from buildbot.process import remotecommand
from buildbot.process.buildstep import create_step_from_step_or_factory
from buildbot.process.locks import get_real_locks_from_accesses
from buildbot.process.properties import Secret
from buildbot.process.properties import renderer
from buildbot.process.results import ALL_RESULTS
from buildbot.process.results import CANCELLED
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SKIPPED
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.test.fake import fakebuild
from buildbot.test.fake import fakemaster
from buildbot.test.fake import worker
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectGlob
from buildbot.test.steps import ExpectMkdir
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.steps import TestBuildStepMixin
from buildbot.test.util import config
from buildbot.test.util import interfaces
from buildbot.util.eventual import eventually
from buildbot.util.twisted import async_to_deferred
class NewStyleStep(buildstep.BuildStep):
def run(self):
pass
class CustomActionBuildStep(buildstep.BuildStep):
# The caller is expected to set the action attribute on the step
def run(self):
return self.action()
def _is_lock_owned_by_step(step, lock):
accesses = [
step_access for step_lock, step_access in step._locks_to_acquire if step_lock == lock
]
if not accesses:
return False
return lock.isOwner(step, accesses[0])
def _is_lock_available_for_step(step, lock):
accesses = [
step_access for step_lock, step_access in step._locks_to_acquire if step_lock == lock
]
if not accesses:
return False
return lock.isAvailable(step, accesses[0])
class TestBuildStep(
TestBuildStepMixin, config.ConfigErrorsMixin, TestReactorMixin, unittest.TestCase
):
class FakeBuildStep(buildstep.BuildStep):
def run(self):
d = defer.Deferred()
eventually(d.callback, 0) # FIXME: this uses real reactor instead of fake one
return d
class SkippingBuildStep(buildstep.BuildStep):
def run(self):
return SKIPPED
class LockBuildStep(buildstep.BuildStep):
def __init__(self, testcase=None, lock_accesses=None, **kwargs):
super().__init__(**kwargs)
self.testcase = testcase
self.lock_accesses = lock_accesses
@defer.inlineCallbacks
def run(self):
locks = yield get_real_locks_from_accesses(self.lock_accesses, self.build)
self.testcase.assertFalse(locks[0][0].isAvailable(self.testcase, self.lock_accesses[0]))
self.testcase.assertFalse(locks[1][0].isAvailable(self.testcase, self.lock_accesses[1]))
return SUCCESS
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
# support
def _setupWaterfallTest(self, hideStepIf, expect, expectedResult=SUCCESS):
self.setup_step(TestBuildStep.FakeBuildStep(hideStepIf=hideStepIf))
self.expect_outcome(result=expectedResult)
self.expect_hidden(expect)
# tests
def test_nameIsntString(self):
"""
When BuildStep is passed a name that isn't a string, it reports
a config error.
"""
with self.assertRaisesConfigError("BuildStep argument name must be an instance of str"):
buildstep.BuildStep(name=5)
def test_name_too_long(self):
with self.assertRaisesConfigError("exceeds maximum length of"):
buildstep.BuildStep(name="b" * 100)
def test_unexpectedKeywordArgument(self):
"""
When BuildStep is passed an unknown keyword argument, it reports
a config error.
"""
with self.assertRaisesConfigError(
"__init__ got unexpected keyword argument(s) ['oogaBooga']"
):
buildstep.BuildStep(oogaBooga=5)
def test_updateBuildSummaryPolicyDefaults(self):
"""
updateBuildSummaryPolicy builds default value according to resultsMixin
parameters (flunkOnFailure..)
"""
step = buildstep.BuildStep()
self.assertEqual(
sorted(step.updateBuildSummaryPolicy), sorted([EXCEPTION, RETRY, CANCELLED, FAILURE])
)
step = buildstep.BuildStep(warnOnWarnings=True)
self.assertEqual(
sorted(step.updateBuildSummaryPolicy),
sorted([EXCEPTION, RETRY, CANCELLED, FAILURE, WARNINGS]),
)
step = buildstep.BuildStep(flunkOnFailure=False)
self.assertEqual(
sorted(step.updateBuildSummaryPolicy), sorted([EXCEPTION, RETRY, CANCELLED])
)
step = buildstep.BuildStep(updateBuildSummaryPolicy=False)
self.assertEqual(sorted(step.updateBuildSummaryPolicy), [])
step = buildstep.BuildStep(updateBuildSummaryPolicy=True)
self.assertEqual(sorted(step.updateBuildSummaryPolicy), sorted(ALL_RESULTS))
def test_updateBuildSummaryPolicyBadType(self):
"""
updateBuildSummaryPolicy raise ConfigError in case of bad type
"""
with self.assertRaisesConfigError(
"BuildStep updateBuildSummaryPolicy must be "
"a list of result ids or boolean but it is 2"
):
buildstep.BuildStep(updateBuildSummaryPolicy=FAILURE)
class RecordingBuildStep(buildstep.BuildStep):
def __init__(self, record_target=None, arg=None, **kwargs):
super().__init__(**kwargs)
self.record_target = record_target
self.arg = arg
def run(self):
self.record_target.append(self.arg)
return SUCCESS
@defer.inlineCallbacks
def test_arg_changes(self):
try:
recorded_arg = []
step = self.RecordingBuildStep(record_target=recorded_arg, arg="orig")
self.setup_step(step)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(recorded_arg, ["orig"])
except ConfigErrors as e:
self.assertEqual(
"Changes to attributes of a BuildStep instance are ignored, this is a bug. "
"Use set_step_arg(name, value) for that.",
e.errors[0],
)
@defer.inlineCallbacks
def test_arg_changes_set_step_arg(self):
recorded_arg = []
step = self.RecordingBuildStep(record_target=recorded_arg, arg="orig")
step.set_step_arg("arg", "changed")
self.setup_step(step)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(recorded_arg, ["changed"])
def test_getProperty(self):
bs = create_step_from_step_or_factory(buildstep.BuildStep())
bs.build = fakebuild.FakeBuild()
props = bs.build.properties = mock.Mock()
bs.getProperty("xyz", 'b')
props.getProperty.assert_called_with("xyz", 'b')
bs.getProperty("xyz")
props.getProperty.assert_called_with("xyz", None)
def test_setProperty(self):
bs = create_step_from_step_or_factory(buildstep.BuildStep())
bs.build = fakebuild.FakeBuild()
props = bs.build.properties = mock.Mock()
bs.setProperty("x", "y", "t")
props.setProperty.assert_called_with("x", "y", "t", runtime=True)
bs.setProperty("x", "abc", "test", runtime=True)
props.setProperty.assert_called_with("x", "abc", "test", runtime=True)
@defer.inlineCallbacks
def test_renderableLocks(self):
master_lock = locks.MasterLock("masterlock")
worker_lock = locks.WorkerLock("workerlock")
lock_accesses = []
@renderer
def rendered_locks(props):
master_access = locks.LockAccess(master_lock, 'counting')
worker_access = locks.LockAccess(worker_lock, 'exclusive')
lock_accesses.append(master_access)
lock_accesses.append(worker_access)
return [master_access, worker_access]
self.setup_step(
self.LockBuildStep(testcase=self, lock_accesses=lock_accesses, locks=rendered_locks)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(len(lock_accesses), 2)
self.assertTrue(
self.get_nth_step(0)._locks_to_acquire[0][0].isAvailable(self, lock_accesses[0])
)
self.assertTrue(
self.get_nth_step(0)._locks_to_acquire[1][0].isAvailable(self, lock_accesses[1])
)
def test_compare(self):
lbs1 = buildstep.BuildStep(name="me")
lbs2 = buildstep.BuildStep(name="me")
lbs3 = buildstep.BuildStep(name="me2")
self.assertEqual(lbs1, lbs2)
self.assertNotEqual(lbs1, lbs3)
def test_repr(self):
self.assertEqual(repr(buildstep.BuildStep(name="me")), 'BuildStep(name=' + repr("me") + ')')
self.assertEqual(repr(NewStyleStep(name="me")), 'NewStyleStep(name=' + repr("me") + ')')
@defer.inlineCallbacks
def test_regularLocks(self):
master_lock = locks.MasterLock("masterlock")
worker_lock = locks.WorkerLock("workerlock")
lock_accesses = [
locks.LockAccess(master_lock, 'counting'),
locks.LockAccess(worker_lock, 'exclusive'),
]
self.setup_step(
self.LockBuildStep(testcase=self, lock_accesses=lock_accesses, locks=lock_accesses)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertTrue(
self.get_nth_step(0)._locks_to_acquire[0][0].isAvailable(self, lock_accesses[0])
)
self.assertTrue(
self.get_nth_step(0)._locks_to_acquire[1][0].isAvailable(self, lock_accesses[1])
)
@defer.inlineCallbacks
def test_regular_locks_skip_step(self):
# BuildStep should not try to acquire locks when it's skipped
lock = locks.MasterLock("masterlock")
lock_access = locks.LockAccess(lock, "exclusive")
self.setup_step(
buildstep.BuildStep(locks=[locks.LockAccess(lock, "counting")], doStepIf=False)
)
locks_list = yield get_real_locks_from_accesses([lock_access], self.build)
locks_list[0][0].claim(self, lock_access)
self.expect_outcome(result=SKIPPED)
yield self.run_step()
@defer.inlineCallbacks
def test_acquire_multiple_locks_after_not_available(self):
lock1 = locks.MasterLock("masterlock1")
lock2 = locks.MasterLock("masterlock2")
stepa = self.setup_step(self.FakeBuildStep(locks=[locks.LockAccess(lock1, 'exclusive')]))
stepb = self.setup_step(self.FakeBuildStep(locks=[locks.LockAccess(lock2, 'exclusive')]))
stepc = self.setup_step(
self.FakeBuildStep(
locks=[locks.LockAccess(lock1, 'exclusive'), locks.LockAccess(lock2, 'exclusive')]
)
)
yield stepa._setup_locks()
yield stepb._setup_locks()
yield stepc._setup_locks()
real_lock1 = stepc._locks_to_acquire[0][0]
real_lock2 = stepc._locks_to_acquire[1][0]
yield stepa.acquireLocks()
yield stepb.acquireLocks()
c_d = stepc.acquireLocks()
self.assertTrue(_is_lock_owned_by_step(stepa, real_lock1))
self.assertFalse(_is_lock_owned_by_step(stepa, real_lock2))
self.assertFalse(_is_lock_owned_by_step(stepb, real_lock1))
self.assertTrue(_is_lock_owned_by_step(stepb, real_lock2))
self.assertFalse(_is_lock_owned_by_step(stepc, real_lock1))
self.assertFalse(_is_lock_owned_by_step(stepc, real_lock2))
self.assertFalse(_is_lock_available_for_step(stepc, real_lock1))
self.assertFalse(_is_lock_available_for_step(stepc, real_lock2))
stepa.releaseLocks()
yield deferLater(self.reactor, 0, lambda: None)
self.assertTrue(_is_lock_available_for_step(stepc, real_lock1))
self.assertFalse(_is_lock_available_for_step(stepc, real_lock2))
stepb.releaseLocks()
yield deferLater(self.reactor, 0, lambda: None)
self.assertTrue(_is_lock_owned_by_step(stepc, real_lock1))
self.assertTrue(_is_lock_owned_by_step(stepc, real_lock2))
yield c_d
@defer.inlineCallbacks
def test_cancel_when_lock_available(self):
lock = locks.MasterLock("masterlock1")
stepa = self.setup_step(self.FakeBuildStep(locks=[locks.LockAccess(lock, 'exclusive')]))
stepb = self.setup_step(self.FakeBuildStep(locks=[locks.LockAccess(lock, 'exclusive')]))
stepc = self.setup_step(self.FakeBuildStep(locks=[locks.LockAccess(lock, 'exclusive')]))
yield stepa._setup_locks()
yield stepb._setup_locks()
yield stepc._setup_locks()
real_lock = stepc._locks_to_acquire[0][0]
yield stepa.acquireLocks()
b_d = stepb.acquireLocks()
c_d = stepc.acquireLocks()
self.assertTrue(_is_lock_owned_by_step(stepa, real_lock))
self.assertFalse(_is_lock_owned_by_step(stepb, real_lock))
self.assertFalse(_is_lock_owned_by_step(stepc, real_lock))
self.assertFalse(_is_lock_available_for_step(stepb, real_lock))
self.assertFalse(_is_lock_available_for_step(stepc, real_lock))
stepa.releaseLocks()
yield deferLater(self.reactor, 0, lambda: None)
self.assertFalse(_is_lock_owned_by_step(stepa, real_lock))
self.assertTrue(_is_lock_owned_by_step(stepb, real_lock))
self.assertFalse(_is_lock_available_for_step(stepc, real_lock))
stepb.interrupt("cancelling")
yield b_d
stepb.releaseLocks()
self.assertFalse(_is_lock_owned_by_step(stepa, real_lock))
self.assertFalse(_is_lock_owned_by_step(stepb, real_lock))
self.assertTrue(_is_lock_available_for_step(stepc, real_lock))
yield c_d
self.assertFalse(_is_lock_owned_by_step(stepa, real_lock))
self.assertFalse(_is_lock_owned_by_step(stepb, real_lock))
self.assertTrue(_is_lock_owned_by_step(stepc, real_lock))
@defer.inlineCallbacks
def test_cancel_when_lock_not_available(self):
lock = locks.MasterLock("masterlock1")
stepa = self.setup_step(self.FakeBuildStep(locks=[locks.LockAccess(lock, 'exclusive')]))
stepb = self.setup_step(self.FakeBuildStep(locks=[locks.LockAccess(lock, 'exclusive')]))
stepc = self.setup_step(self.FakeBuildStep(locks=[locks.LockAccess(lock, 'exclusive')]))
yield stepa._setup_locks()
yield stepb._setup_locks()
yield stepc._setup_locks()
real_lock = stepc._locks_to_acquire[0][0]
yield stepa.acquireLocks()
b_d = stepb.acquireLocks()
c_d = stepc.acquireLocks()
self.assertTrue(_is_lock_owned_by_step(stepa, real_lock))
self.assertFalse(_is_lock_owned_by_step(stepb, real_lock))
self.assertFalse(_is_lock_owned_by_step(stepc, real_lock))
self.assertFalse(_is_lock_available_for_step(stepb, real_lock))
self.assertFalse(_is_lock_available_for_step(stepc, real_lock))
stepb.interrupt("cancelling")
yield b_d
stepa.releaseLocks()
yield deferLater(self.reactor, 0, lambda: None)
self.assertFalse(_is_lock_owned_by_step(stepa, real_lock))
self.assertFalse(_is_lock_owned_by_step(stepb, real_lock))
self.assertTrue(_is_lock_owned_by_step(stepc, real_lock))
yield c_d
self.assertFalse(_is_lock_owned_by_step(stepa, real_lock))
self.assertFalse(_is_lock_owned_by_step(stepb, real_lock))
self.assertTrue(_is_lock_owned_by_step(stepc, real_lock))
@defer.inlineCallbacks
def test_checks_step_and_builder_locks_not_same(self):
lock = locks.MasterLock("masterlock1")
step = self.setup_step(self.FakeBuildStep(locks=[lock.access("exclusive")]))
lock_list = yield get_real_locks_from_accesses([lock.access("counting")], self.build)
self.build._locks_to_acquire = lock_list
with self.assertRaises(RuntimeError) as e:
yield step._setup_locks()
self.assertEqual(
e.exception.args,
("lock claimed by both Step and Build (<MasterLock(masterlock1, 1)>)",),
)
@defer.inlineCallbacks
def test_multiple_cancel(self):
step = self.setup_step(CustomActionBuildStep())
def double_interrupt():
step.interrupt('reason1')
step.interrupt('reason2')
return CANCELLED
step.action = double_interrupt
self.expect_outcome(result=CANCELLED)
yield self.run_step()
@defer.inlineCallbacks
def test_runCommand(self):
bs = create_step_from_step_or_factory(buildstep.BuildStep())
bs.worker = worker.FakeWorker(master=None) # master is not used here
bs.remote = 'dummy'
bs.build = fakebuild.FakeBuild()
bs.build.builder.name = 'fake'
cmd = remotecommand.RemoteShellCommand("build", ["echo", "hello"])
def run(*args, **kwargs):
# check that runCommand sets step.cmd
self.assertIdentical(bs.cmd, cmd)
return SUCCESS
cmd.run = run
yield bs.runCommand(cmd)
# check that step.cmd is cleared after the command runs
self.assertEqual(bs.cmd, None)
@defer.inlineCallbacks
def test_run_command_after_interrupt(self):
step = self.setup_step(CustomActionBuildStep())
cmd = remotecommand.RemoteShellCommand("build", ["echo", "hello"])
def run(*args, **kwargs):
raise RuntimeError("Command must not be run when step is interrupted")
cmd.run = run
@defer.inlineCallbacks
def interrupt_and_run_command():
step.interrupt('reason1')
res = yield step.runCommand(cmd)
return res
step.action = interrupt_and_run_command
self.expect_outcome(result=CANCELLED)
yield self.run_step()
@defer.inlineCallbacks
def test_lost_remote_during_interrupt(self):
step = self.setup_step(CustomActionBuildStep())
cmd = remotecommand.RemoteShellCommand("build", ["echo", "hello"])
@defer.inlineCallbacks
def on_command(cmd):
conn = cmd.conn
conn.set_expect_interrupt()
conn.set_block_on_interrupt()
d1 = step.interrupt('interrupt reason')
d2 = step.interrupt(failure.Failure(error.ConnectionLost()))
conn.unblock_waiters()
yield d1
yield d2
self.expect_commands(
ExpectShell(workdir='build', command=['echo', 'hello'])
.behavior(on_command)
.break_connection()
)
@defer.inlineCallbacks
def run_command():
res = yield step.runCommand(cmd)
return res.results()
step.action = run_command
self.expect_outcome(result=RETRY)
yield self.run_step()
@defer.inlineCallbacks
def test_start_returns_SKIPPED(self):
self.setup_step(self.SkippingBuildStep())
self.get_nth_step(0).finished = mock.Mock()
self.expect_outcome(result=SKIPPED, state_string='finished (skipped)')
yield self.run_step()
# 837: we want to specifically avoid calling finished() if skipping
self.get_nth_step(0).finished.assert_not_called()
@defer.inlineCallbacks
def test_doStepIf_false(self):
self.setup_step(self.FakeBuildStep(doStepIf=False))
self.get_nth_step(0).finished = mock.Mock()
self.expect_outcome(result=SKIPPED, state_string='finished (skipped)')
yield self.run_step()
# 837: we want to specifically avoid calling finished() if skipping
self.get_nth_step(0).finished.assert_not_called()
@defer.inlineCallbacks
def test_doStepIf_renderable_false(self):
@util.renderer
def dostepif(props):
return False
self.setup_step(self.FakeBuildStep(doStepIf=dostepif))
self.get_nth_step(0).finished = mock.Mock()
self.expect_outcome(result=SKIPPED, state_string='finished (skipped)')
yield self.run_step()
# 837: we want to specifically avoid calling finished() if skipping
self.get_nth_step(0).finished.assert_not_called()
@defer.inlineCallbacks
def test_doStepIf_returns_false(self):
self.setup_step(self.FakeBuildStep(doStepIf=lambda step: False))
self.get_nth_step(0).finished = mock.Mock()
self.expect_outcome(result=SKIPPED, state_string='finished (skipped)')
yield self.run_step()
# 837: we want to specifically avoid calling finished() if skipping
self.get_nth_step(0).finished.assert_not_called()
@defer.inlineCallbacks
def test_doStepIf_returns_deferred_false(self):
self.setup_step(self.FakeBuildStep(doStepIf=lambda step: defer.succeed(False)))
self.get_nth_step(0).finished = mock.Mock()
self.expect_outcome(result=SKIPPED, state_string='finished (skipped)')
yield self.run_step()
# 837: we want to specifically avoid calling finished() if skipping
self.get_nth_step(0).finished.assert_not_called()
def test_hideStepIf_False(self):
self._setupWaterfallTest(False, False)
return self.run_step()
def test_hideStepIf_True(self):
self._setupWaterfallTest(True, True)
return self.run_step()
@defer.inlineCallbacks
def test_hideStepIf_Callable_False(self):
called = [False]
def shouldHide(result, step):
called[0] = True
self.assertTrue(step is self.get_nth_step(0))
self.assertEqual(result, SUCCESS)
return False
self._setupWaterfallTest(shouldHide, False)
yield self.run_step()
self.assertTrue(called[0])
@defer.inlineCallbacks
def test_hideStepIf_Callable_True(self):
called = [False]
def shouldHide(result, step):
called[0] = True
self.assertTrue(step is self.get_nth_step(0))
self.assertEqual(result, SUCCESS)
return True
self._setupWaterfallTest(shouldHide, True)
yield self.run_step()
self.assertTrue(called[0])
@defer.inlineCallbacks
def test_hideStepIf_fails(self):
# 0/0 causes DivideByZeroError, which should be flagged as an exception
self._setupWaterfallTest(lambda x, y: 0 / 0, False, expectedResult=EXCEPTION)
self.get_nth_step(0).addLogWithFailure = mock.Mock()
yield self.run_step()
self.assertEqual(len(self.flushLoggedErrors(ZeroDivisionError)), 1)
@defer.inlineCallbacks
def test_hideStepIf_Callable_Exception(self):
called = [False]
def shouldHide(result, step):
called[0] = True
self.assertTrue(step is self.get_nth_step(0))
self.assertEqual(result, EXCEPTION)
return True
def createException(*args, **kwargs):
raise RuntimeError()
self.setup_step(self.FakeBuildStep(hideStepIf=shouldHide, doStepIf=createException))
self.expect_outcome(result=EXCEPTION, state_string='finished (exception)')
self.expect_hidden(True)
try:
yield self.run_step()
except Exception as e:
log.err(e)
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
self.assertTrue(called[0])
@defer.inlineCallbacks
def test_step_getLog(self):
testcase = self
class TestGetLogStep(buildstep.BuildStep):
@defer.inlineCallbacks
def run(self):
testcase.assertRaises(KeyError, lambda: self.getLog('testy'))
log1 = yield self.addLog('testy')
log2 = self.getLog('testy')
testcase.assertIdentical(log1, log2)
return SUCCESS
self.setup_step(TestGetLogStep())
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_step_renders_flunkOnFailure(self):
self.setup_step(TestBuildStep.FakeBuildStep(flunkOnFailure=properties.Property('fOF')))
self.build.setProperty('fOF', 'yes', 'test')
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(self.get_nth_step(0).flunkOnFailure, 'yes')
def test_hasStatistic(self):
step = buildstep.BuildStep()
self.assertFalse(step.hasStatistic('rbi'))
step.setStatistic('rbi', 13)
self.assertTrue(step.hasStatistic('rbi'))
def test_setStatistic(self):
step = buildstep.BuildStep()
step.setStatistic('rbi', 13)
self.assertEqual(step.getStatistic('rbi'), 13)
def test_getStatistic(self):
step = buildstep.BuildStep()
self.assertEqual(step.getStatistic('rbi', 99), 99)
self.assertEqual(step.getStatistic('rbi'), None)
step.setStatistic('rbi', 13)
self.assertEqual(step.getStatistic('rbi'), 13)
def test_getStatistics(self):
step = buildstep.BuildStep()
step.setStatistic('rbi', 13)
step.setStatistic('ba', 0.298)
self.assertEqual(step.getStatistics(), {'rbi': 13, 'ba': 0.298})
@defer.inlineCallbacks
def setup_summary_test(self):
self.patch(NewStyleStep, 'getCurrentSummary', lambda self: defer.succeed({'step': 'C'}))
self.patch(
NewStyleStep,
'getResultSummary',
lambda self: defer.succeed({'step': 'CS', 'build': 'CB'}),
)
step = create_step_from_step_or_factory(NewStyleStep())
step.master = yield fakemaster.make_master(self, wantData=True, wantDb=True)
step.stepid = 13
step.build = fakebuild.FakeBuild()
return step
@defer.inlineCallbacks
def test_updateSummary_running(self):
step = yield self.setup_summary_test()
step._running = True
step.updateSummary()
self.reactor.advance(1)
self.assertEqual(step.master.data.updates.stepStateString[13], 'C')
@defer.inlineCallbacks
def test_updateSummary_running_empty_dict(self):
step = yield self.setup_summary_test()
step.getCurrentSummary = lambda: {}
step._running = True
step.updateSummary()
self.reactor.advance(1)
self.assertEqual(step.master.data.updates.stepStateString[13], 'finished')
@defer.inlineCallbacks
def test_updateSummary_running_not_unicode(self):
step = yield self.setup_summary_test()
step.getCurrentSummary = lambda: {'step': b'bytestring'}
step._running = True
step.updateSummary()
self.reactor.advance(1)
self.assertEqual(len(self.flushLoggedErrors(TypeError)), 1)
@defer.inlineCallbacks
def test_updateSummary_running_not_dict(self):
step = yield self.setup_summary_test()
step.getCurrentSummary = lambda: 'foo!'
step._running = True
step.updateSummary()
self.reactor.advance(1)
self.assertEqual(len(self.flushLoggedErrors(TypeError)), 1)
@defer.inlineCallbacks
def test_updateSummary_finished(self):
step = yield self.setup_summary_test()
step._running = False
step.updateSummary()
self.reactor.advance(1)
self.assertEqual(step.master.data.updates.stepStateString[13], 'CS')
@defer.inlineCallbacks
def test_updateSummary_finished_empty_dict(self):
step = yield self.setup_summary_test()
step.getResultSummary = lambda: {}
step._running = False
step.updateSummary()
self.reactor.advance(1)
self.assertEqual(step.master.data.updates.stepStateString[13], 'finished')
@defer.inlineCallbacks
def test_updateSummary_finished_not_dict(self):
step = yield self.setup_summary_test()
step.getResultSummary = lambda: 'foo!'
step._running = False
step.updateSummary()
self.reactor.advance(1)
self.assertEqual(len(self.flushLoggedErrors(TypeError)), 1)
def checkSummary(self, got, step, build=None):
self.assertTrue(all(isinstance(k, str) for k in got))
self.assertTrue(all(isinstance(k, str) for k in got.values()))
exp = {'step': step}
if build:
exp['build'] = build
self.assertEqual(got, exp)
def test_getCurrentSummary(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.description = None
self.checkSummary(st.getCurrentSummary(), 'running')
def test_getCurrentSummary_description(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.description = 'fooing'
self.checkSummary(st.getCurrentSummary(), 'fooing')
def test_getCurrentSummary_descriptionSuffix(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.description = 'fooing'
st.descriptionSuffix = 'bar'
self.checkSummary(st.getCurrentSummary(), 'fooing bar')
def test_getCurrentSummary_description_list(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.description = ['foo', 'ing']
self.checkSummary(st.getCurrentSummary(), 'foo ing')
def test_getCurrentSummary_descriptionSuffix_list(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SUCCESS
st.description = ['foo', 'ing']
st.descriptionSuffix = ['bar', 'bar2']
self.checkSummary(st.getCurrentSummary(), 'foo ing bar bar2')
def test_getResultSummary(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SUCCESS
st.description = None
self.checkSummary(st.getResultSummary(), 'finished')
def test_getResultSummary_description(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SUCCESS
st.description = 'fooing'
self.checkSummary(st.getResultSummary(), 'fooing')
def test_getResultSummary_descriptionDone(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SUCCESS
st.description = 'fooing'
st.descriptionDone = 'fooed'
self.checkSummary(st.getResultSummary(), 'fooed')
def test_getResultSummary_descriptionSuffix(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SUCCESS
st.description = 'fooing'
st.descriptionSuffix = 'bar'
self.checkSummary(st.getResultSummary(), 'fooing bar')
def test_getResultSummary_descriptionDone_and_Suffix(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SUCCESS
st.descriptionDone = 'fooed'
st.descriptionSuffix = 'bar'
self.checkSummary(st.getResultSummary(), 'fooed bar')
def test_getResultSummary_description_list(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SUCCESS
st.description = ['foo', 'ing']
self.checkSummary(st.getResultSummary(), 'foo ing')
def test_getResultSummary_descriptionSuffix_list(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SUCCESS
st.description = ['foo', 'ing']
st.descriptionSuffix = ['bar', 'bar2']
self.checkSummary(st.getResultSummary(), 'foo ing bar bar2')
@defer.inlineCallbacks
def test_getResultSummary_descriptionSuffix_failure(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = FAILURE
st.description = 'fooing'
self.checkSummary(
(yield st.getBuildResultSummary()), 'fooing (failure)', 'fooing (failure)'
)
self.checkSummary(st.getResultSummary(), 'fooing (failure)')
@defer.inlineCallbacks
def test_getResultSummary_descriptionSuffix_skipped(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = SKIPPED
st.description = 'fooing'
self.checkSummary((yield st.getBuildResultSummary()), 'fooing (skipped)')
self.checkSummary(st.getResultSummary(), 'fooing (skipped)')
@defer.inlineCallbacks
def test_getResultSummary_description_failure_timed_out(self):
st = create_step_from_step_or_factory(buildstep.BuildStep())
st.results = FAILURE
st.description = "fooing"
st.timed_out = True
self.checkSummary(
(yield st.getBuildResultSummary()),
"fooing (failure) (timed out)",
"fooing (failure) (timed out)",
)
self.checkSummary(st.getResultSummary(), "fooing (failure) (timed out)")
# Test calling checkWorkerHasCommand() when worker have support for
# requested remote command.
def testcheckWorkerHasCommandGood(self):
# patch BuildStep.workerVersion() to return success
mockedWorkerVersion = mock.Mock()
self.patch(buildstep.BuildStep, "workerVersion", mockedWorkerVersion)
# check that no exceptions are raised
buildstep.BuildStep().checkWorkerHasCommand("foo")
# make sure workerVersion() was called with correct arguments
mockedWorkerVersion.assert_called_once_with("foo")
# Test calling checkWorkerHasCommand() when worker is to old to support
# requested remote command.
def testcheckWorkerHasCommandTooOld(self):
# patch BuildStep.workerVersion() to return error
self.patch(buildstep.BuildStep, "workerVersion", mock.Mock(return_value=None))
# make sure appropriate exception is raised
step = buildstep.BuildStep()
with self.assertRaisesRegex(WorkerSetupError, "worker is too old, does not know about foo"):
step.checkWorkerHasCommand("foo")
@defer.inlineCallbacks
def testRunRaisesException(self):
step = create_step_from_step_or_factory(NewStyleStep())
step.master = mock.Mock()
step.master.reactor = self.reactor
step.build = mock.Mock()
step.build._locks_to_acquire = []
step.build.properties.cleanupTextFromSecrets = lambda s: s
step.build.builder.botmaster.getLockFromLockAccesses = mock.Mock(return_value=[])
step.locks = []
step.renderables = []
step.build.render = defer.succeed
step.master.data.updates.addStep = lambda **kwargs: defer.succeed((0, 0, 0))
step.addLogWithFailure = lambda x: defer.succeed(None)
step.run = lambda: defer.fail(RuntimeError('got exception'))
res = yield step.startStep(mock.Mock())
self.assertFalse(step._running)
errors = self.flushLoggedErrors()
self.assertEqual(len(errors), 1)
self.assertEqual(errors[0].getErrorMessage(), 'got exception')
self.assertEqual(res, EXCEPTION)
class InterfaceTests(interfaces.InterfaceTests):
# ensure that TestBuildStepMixin creates a convincing facsimile of the
# real BuildStep
def test_signature_attributes(self):
for attr in [
'name',
'description',
'descriptionDone',
'descriptionSuffix',
'locks',
'progressMetrics',
'useProgress',
'doStepIf',
'hideStepIf',
'haltOnFailure',
'flunkOnWarnings',
'flunkOnFailure',
'warnOnWarnings',
'warnOnFailure',
'alwaysRun',
'build',
'worker',
'progress',
'stopped',
]:
self.assertTrue(hasattr(self.get_nth_step(0), attr))
def test_signature_setBuild(self):
@self.assertArgSpecMatches(self.get_nth_step(0).setBuild)
def setBuild(self, build):
pass
def test_signature_setWorker(self):
@self.assertArgSpecMatches(self.get_nth_step(0).setWorker)
def setWorker(self, worker):
pass
def test_signature_setupProgress(self):
@self.assertArgSpecMatches(self.get_nth_step(0).setupProgress)
def setupProgress(self):
pass
def test_signature_startStep(self):
@self.assertArgSpecMatches(self.get_nth_step(0).startStep)
def startStep(self, remote):
pass
def test_signature_run(self):
@self.assertArgSpecMatches(self.get_nth_step(0).run)
def run(self):
pass
def test_signature_interrupt(self):
@self.assertArgSpecMatches(self.get_nth_step(0).interrupt)
def interrupt(self, reason):
pass
def test_signature_setProgress(self):
@self.assertArgSpecMatches(self.get_nth_step(0).setProgress)
def setProgress(self, metric, value):
pass
def test_signature_workerVersion(self):
@self.assertArgSpecMatches(self.get_nth_step(0).workerVersion)
def workerVersion(self, command, oldversion=None):
pass
def test_signature_workerVersionIsOlderThan(self):
@self.assertArgSpecMatches(self.get_nth_step(0).workerVersionIsOlderThan)
def workerVersionIsOlderThan(self, command, minversion):
pass
def test_signature_getWorkerName(self):
@self.assertArgSpecMatches(self.get_nth_step(0).getWorkerName)
def getWorkerName(self):
pass
def test_signature_runCommand(self):
@self.assertArgSpecMatches(self.get_nth_step(0).runCommand)
def runCommand(self, command):
pass
def test_signature_addURL(self):
@self.assertArgSpecMatches(self.get_nth_step(0).addURL)
def addURL(self, name, url):
pass
def test_signature_addLog(self):
@self.assertArgSpecMatches(self.get_nth_step(0).addLog)
def addLog(self, name, type='s', logEncoding=None):
pass
def test_signature_getLog(self):
@self.assertArgSpecMatches(self.get_nth_step(0).getLog)
def getLog(self, name):
pass
def test_signature_addCompleteLog(self):
@self.assertArgSpecMatches(self.get_nth_step(0).addCompleteLog)
def addCompleteLog(self, name, text):
pass
def test_signature_addHTMLLog(self):
@self.assertArgSpecMatches(self.get_nth_step(0).addHTMLLog)
def addHTMLLog(self, name, html):
pass
def test_signature_addLogObserver(self):
@self.assertArgSpecMatches(self.get_nth_step(0).addLogObserver)
def addLogObserver(self, logname, observer):
pass
class TestFakeItfc(unittest.TestCase, TestBuildStepMixin, TestReactorMixin, InterfaceTests):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setup_test_build_step()
self.setup_step(buildstep.BuildStep())
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
class TestRealItfc(unittest.TestCase, InterfaceTests):
def setUp(self):
self.step = buildstep.BuildStep()
def get_nth_step(self, index):
return self.step
class CommandMixinExample(buildstep.CommandMixin, buildstep.BuildStep):
@defer.inlineCallbacks
def run(self):
rv = yield self.testMethod()
self.method_return_value = rv
return SUCCESS
class TestCommandMixin(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setup_test_build_step()
self.setup_step(CommandMixinExample())
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_runRmdir(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).runRmdir('/some/path')
self.expect_commands(ExpectRmdir(dir='/some/path', log_environ=False).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertTrue(self.get_nth_step(0).method_return_value)
@defer.inlineCallbacks
def test_runMkdir(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).runMkdir('/some/path')
self.expect_commands(ExpectMkdir(dir='/some/path', log_environ=False).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertTrue(self.get_nth_step(0).method_return_value)
@defer.inlineCallbacks
def test_runMkdir_fails(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).runMkdir('/some/path')
self.expect_commands(ExpectMkdir(dir='/some/path', log_environ=False).exit(1))
self.expect_outcome(result=FAILURE)
yield self.run_step()
@defer.inlineCallbacks
def test_runMkdir_fails_no_abandon(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).runMkdir(
'/some/path', abandonOnFailure=False
)
self.expect_commands(ExpectMkdir(dir='/some/path', log_environ=False).exit(1))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertFalse(self.get_nth_step(0).method_return_value)
@defer.inlineCallbacks
def test_pathExists(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).pathExists('/some/path')
self.expect_commands(ExpectStat(file='/some/path', log_environ=False).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertTrue(self.get_nth_step(0).method_return_value)
@defer.inlineCallbacks
def test_pathExists_doesnt(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).pathExists('/some/path')
self.expect_commands(ExpectStat(file='/some/path', log_environ=False).exit(1))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertFalse(self.get_nth_step(0).method_return_value)
@defer.inlineCallbacks
def test_pathExists_logging(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).pathExists('/some/path')
self.expect_commands(
ExpectStat(file='/some/path', log_environ=False)
.log('stdio', header='NOTE: never mind\n')
.exit(1)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertFalse(self.get_nth_step(0).method_return_value)
self.assertEqual(
self.get_nth_step(0).getLog('stdio').header,
'NOTE: never mind\nprogram finished with exit code 1\n',
)
def test_glob(self):
@defer.inlineCallbacks
def testFunc():
res = yield self.get_nth_step(0).runGlob("*.pyc")
self.assertEqual(res, ["one.pyc", "two.pyc"])
self.get_nth_step(0).testMethod = testFunc
self.expect_commands(
ExpectGlob(path='*.pyc', log_environ=False).files(["one.pyc", "two.pyc"]).exit(0)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_glob_empty(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).runGlob("*.pyc")
self.expect_commands(ExpectGlob(path='*.pyc', log_environ=False).files().exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_glob_fail(self):
self.get_nth_step(0).testMethod = lambda: self.get_nth_step(0).runGlob("*.pyc")
self.expect_commands(ExpectGlob(path='*.pyc', log_environ=False).exit(1))
self.expect_outcome(result=FAILURE)
return self.run_step()
class SimpleShellCommand(buildstep.ShellMixin, buildstep.BuildStep):
def __init__(self, make_cmd_kwargs=None, prohibit_args=None, **kwargs):
self.make_cmd_kwargs = make_cmd_kwargs or {}
kwargs = self.setupShellMixin(kwargs, prohibitArgs=prohibit_args)
super().__init__(**kwargs)
@defer.inlineCallbacks
def run(self):
cmd = yield self.makeRemoteShellCommand(**self.make_cmd_kwargs)
yield self.runCommand(cmd)
return cmd.results()
class TestShellMixin(
TestBuildStepMixin, config.ConfigErrorsMixin, TestReactorMixin, unittest.TestCase
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setup_test_build_step(with_secrets={"s3cr3t": "really_safe_string"})
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_setupShellMixin_bad_arg(self):
mixin = SimpleShellCommand()
with self.assertRaisesConfigError("invalid SimpleShellCommand argument invarg"):
mixin.setupShellMixin({'invarg': 13})
def test_setupShellMixin_prohibited_arg(self):
mixin = SimpleShellCommand()
with self.assertRaisesConfigError("invalid SimpleShellCommand argument logfiles"):
mixin.setupShellMixin({'logfiles': None}, prohibitArgs=['logfiles'])
def test_constructor_defaults(self):
class MySubclass(SimpleShellCommand):
timeout = 9999
# ShellMixin arg
self.assertEqual(MySubclass().timeout, 9999)
self.assertEqual(MySubclass(timeout=88).timeout, 88)
# BuildStep arg
self.assertEqual(MySubclass().logEncoding, None)
self.assertEqual(MySubclass(logEncoding='latin-1').logEncoding, 'latin-1')
self.assertEqual(MySubclass().description, None)
self.assertEqual(MySubclass(description='charming').description, ['charming'])
@defer.inlineCallbacks
def test_prohibit_args(self):
self.setup_step(
SimpleShellCommand(
prohibit_args=['command'], make_cmd_kwargs={'command': ['cmd', 'arg']}
)
)
self.expect_commands(ExpectShell(workdir='wkdir', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
def test_bad_arg_type(self):
mixin = SimpleShellCommand()
with self.assertRaisesConfigError(
"SimpleShellCommand argument usePTY must be an instance of bool"
):
mixin.setupShellMixin({'usePTY': 13})
@defer.inlineCallbacks
def test_no_default_workdir(self):
self.setup_step(SimpleShellCommand(command=['cmd', 'arg']), want_default_work_dir=False)
self.expect_commands(ExpectShell(workdir='build', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_build_workdir(self):
self.setup_step(SimpleShellCommand(command=['cmd', 'arg']), want_default_work_dir=False)
self.build.workdir = '/alternate'
self.expect_commands(ExpectShell(workdir='/alternate', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_build_workdir_callable(self):
self.setup_step(SimpleShellCommand(command=['cmd', 'arg']), want_default_work_dir=False)
self.build.workdir = lambda x: '/alternate'
self.expect_commands(ExpectShell(workdir='/alternate', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_build_workdir_callable_error(self):
self.setup_step(SimpleShellCommand(command=['cmd', 'arg']), want_default_work_dir=False)
self.build.workdir = lambda x: x.nosuchattribute # will raise AttributeError
self.expect_exception(buildstep.CallableAttributeError)
yield self.run_step()
@defer.inlineCallbacks
def test_build_workdir_renderable(self):
self.setup_step(SimpleShellCommand(command=['cmd', 'arg']), want_default_work_dir=False)
self.build.workdir = properties.Property("myproperty")
self.build.setProperty("myproperty", "/myproperty", "test")
self.expect_commands(ExpectShell(workdir='/myproperty', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_step_workdir(self):
self.setup_step(SimpleShellCommand(command=['cmd', 'arg'], workdir='/stepdir'))
self.build.workdir = '/builddir'
self.expect_commands(ExpectShell(workdir='/stepdir', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_step_renderable_workdir(self):
@renderer
def rendered_workdir(_):
return '/stepdir'
self.setup_step(SimpleShellCommand(command=['cmd', 'arg'], workdir=rendered_workdir))
self.build.workdir = '/builddir'
self.expect_commands(ExpectShell(workdir='/stepdir', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_step_workdir_overridden(self):
self.setup_step(
SimpleShellCommand(
command=['cmd', 'arg'],
workdir='/stepdir',
make_cmd_kwargs={'workdir': '/overridden'},
)
)
self.build.workdir = '/builddir'
self.expect_commands(ExpectShell(workdir='/overridden', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_step_env_default(self):
env = {'ENV': 'TRUE'}
self.setup_step(SimpleShellCommand(command=['cmd', 'arg'], env=env))
self.expect_commands(ExpectShell(workdir='wkdir', command=['cmd', 'arg'], env=env).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_step_env_overridden(self):
env = {'ENV': 'TRUE'}
env_override = {'OVERRIDE': 'TRUE'}
self.setup_step(
SimpleShellCommand(
command=['cmd', 'arg'], env=env, make_cmd_kwargs={'env': env_override}
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cmd', 'arg'], env=env_override).exit(0)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_extra_logfile(self):
self.setup_step(
SimpleShellCommand(command=['cmd', 'arg'], logfiles={'logname': 'logpath.log'})
)
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['cmd', 'arg'], logfiles={'logname': 'logpath.log'}
)
.log('logname', stdout='logline\nlogline2\n')
.stdout("some log\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(self.get_nth_step(0).getLog('logname').stdout, 'logline\nlogline2\n')
@defer.inlineCallbacks
def test_lazy_logfiles_stdout_has_stdout(self):
self.setup_step(SimpleShellCommand(command=['cmd', 'arg'], lazylogfiles=True))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cmd', 'arg']).stdout("some log\n").exit(0)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(self.get_nth_step(0).getLog('stdio').stdout, 'some log\n')
@defer.inlineCallbacks
def test_lazy_logfiles_stdout_no_stdout(self):
# lazy log files do not apply to stdout
self.setup_step(SimpleShellCommand(command=['cmd', 'arg'], lazylogfiles=True))
self.expect_commands(ExpectShell(workdir='wkdir', command=['cmd', 'arg']).exit(0))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(self.get_nth_step(0).getLog('stdio').stdout, '')
@defer.inlineCallbacks
def test_lazy_logfiles_logfile(self):
self.setup_step(
SimpleShellCommand(
command=['cmd', 'arg'], lazylogfiles=True, logfiles={'logname': 'logpath.log'}
)
)
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['cmd', 'arg'], logfiles={'logname': 'logpath.log'}
)
.log('logname', stdout='logline\nlogline2\n')
.exit(0)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(self.get_nth_step(0).getLog('logname').stdout, 'logline\nlogline2\n')
@defer.inlineCallbacks
def test_lazy_logfiles_no_logfile(self):
self.setup_step(
SimpleShellCommand(
command=['cmd', 'arg'], lazylogfiles=True, logfiles={'logname': 'logpath.log'}
)
)
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['cmd', 'arg'], logfiles={'logname': 'logpath.log'}
).exit(0)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
with self.assertRaises(KeyError):
self.get_nth_step(0).getLog('logname')
@defer.inlineCallbacks
def test_env(self):
self.setup_step(SimpleShellCommand(command=['cmd', 'arg'], env={'BAR': 'BAR'}))
self.build.builder.config.env = {'FOO': 'FOO'}
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['cmd', 'arg'], env={'FOO': 'FOO', 'BAR': 'BAR'}
).exit(0)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
@defer.inlineCallbacks
def test_old_worker_args(self):
self.setup_build(worker_version={'*': "1.1"})
self.setup_step(
SimpleShellCommand(command=['cmd', 'arg'], usePTY=False, interruptSignal='DIE')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cmd', 'arg']).exit(0)
# note missing parameters
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(
self.get_nth_step(0).getLog('stdio').header,
'NOTE: worker does not allow master to override usePTY\n'
'NOTE: worker does not allow master to specify interruptSignal\n'
'program finished with exit code 0\n',
)
@defer.inlineCallbacks
def test_new_worker_args(self):
self.setup_build(worker_version={'*': "3.0"})
self.setup_step(
SimpleShellCommand(command=['cmd', 'arg'], usePTY=False, interruptSignal='DIE')
)
self.expect_commands(
ExpectShell(
workdir='wkdir', use_pty=False, interrupt_signal='DIE', command=['cmd', 'arg']
).exit(0)
)
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertEqual(
self.get_nth_step(0).getLog('stdio').header, 'program finished with exit code 0\n'
)
@defer.inlineCallbacks
def test_description(self):
self.setup_step(SimpleShellCommand(command=['foo', properties.Property('bar', 'BAR')]))
self.expect_commands(ExpectShell(workdir='wkdir', command=['foo', 'BAR']).exit(0))
self.expect_outcome(result=SUCCESS, state_string="'foo BAR'")
yield self.run_step()
@parameterized.expand(["timeout", "timeout_without_output"])
@defer.inlineCallbacks
def test_description_timed_out(self, failure_reason):
self.setup_step(SimpleShellCommand(command=["foo"]))
self.expect_commands(
ExpectShell(workdir="wkdir", command=["foo"])
.update("failure_reason", failure_reason)
.exit(1)
)
self.expect_outcome(result=FAILURE, state_string="'foo' (failure) (timed out)")
yield self.run_step()
def test_getResultSummary(self):
self.setup_step(SimpleShellCommand(command=['a', ['b', 'c']]))
self.get_nth_step(0).results = SUCCESS
self.assertEqual(self.get_nth_step(0).getResultSummary(), {'step': "'a b ...'"})
@async_to_deferred
async def test_step_with_secret_success(self):
self.setup_step(SimpleShellCommand(command=["echo", Secret("s3cr3t")]))
self.expect_commands(
ExpectShell(workdir="wkdir", command=["echo", 'really_safe_string']).exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="'echo <s3cr3t>'")
summary = "'echo <s3cr3t>'"
self.expect_result_summary({'step': summary})
self.expect_build_result_summary({'step': summary})
await self.run_step()
@async_to_deferred
async def test_step_with_secret_failure(self):
self.setup_step(SimpleShellCommand(command=["echo", Secret("s3cr3t")]))
self.expect_commands(
ExpectShell(workdir="wkdir", command=["echo", 'really_safe_string']).exit(1)
)
self.expect_outcome(result=FAILURE, state_string="'echo <s3cr3t>' (failure)")
summary = "'echo <s3cr3t>' (failure)"
self.expect_result_summary({'step': summary})
self.expect_build_result_summary({'step': summary, 'build': summary})
await self.run_step()
| 59,149 | Python | .py | 1,290 | 37.064341 | 100 | 0.659149 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,448 | test_builder.py | buildbot_buildbot/master/buildbot/test/unit/process/test_builder.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import random
from unittest import mock
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.config.master import MasterConfig
from buildbot.process import builder
from buildbot.process import factory
from buildbot.process.properties import Properties
from buildbot.process.properties import renderer
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.warnings import assertProducesWarning
from buildbot.util import epoch2datetime
from buildbot.worker import AbstractLatentWorker
class BuilderMixin:
@defer.inlineCallbacks
def setUpBuilderMixin(self):
self.factory = factory.BuildFactory()
self.master = yield fakemaster.make_master(self, wantData=True)
self.mq = self.master.mq
self.db = self.master.db
# returns a Deferred that returns None
def makeBuilder(self, name="bldr", patch_random=False, noReconfig=False, **config_kwargs):
"""Set up C{self.bldr}"""
# only include the necessary required config, plus user-requested
self.config_args = {
'name': name,
'workername': 'wrk',
'builddir': 'bdir',
'workerbuilddir': "wbdir",
'factory': self.factory,
}
self.config_args.update(config_kwargs)
self.builder_config = config.BuilderConfig(**self.config_args)
self.bldr = builder.Builder(self.builder_config.name)
self.bldr.master = self.master
self.bldr.botmaster = self.master.botmaster
# patch into the _startBuildsFor method
self.builds_started = []
def _startBuildFor(workerforbuilder, buildrequests):
self.builds_started.append((workerforbuilder, buildrequests))
return defer.succeed(True)
self.bldr._startBuildFor = _startBuildFor
if patch_random:
# patch 'random.choice' to always take the worker 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 = MasterConfig()
mastercfg.builders = [self.builder_config]
if not noReconfig:
return self.bldr.reconfigServiceWithBuildbotConfig(mastercfg)
class FakeWorker:
builds_may_be_incompatible = False
def __init__(self, workername):
self.workername = workername
class FakeLatentWorker(AbstractLatentWorker):
builds_may_be_incompatible = True
def __init__(self, is_compatible_with_build):
self.is_compatible_with_build = is_compatible_with_build
def isCompatibleWithBuild(self, build_props):
return defer.succeed(self.is_compatible_with_build)
def checkConfig(self, name, _, **kwargs):
pass
def reconfigService(self, name, _, **kwargs):
pass
class TestBuilder(TestReactorMixin, BuilderMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
# a collection of rows that would otherwise clutter up every test
yield self.setUpBuilderMixin()
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(buildsetid=11, sourcestampid=21),
]
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def makeBuilder(self, patch_random=False, startBuildsForSucceeds=True, **config_kwargs):
yield super().makeBuilder(patch_random=patch_random, **config_kwargs)
# patch into the _startBuildsFor method
self.builds_started = []
def _startBuildFor(workerforbuilder, buildrequests):
self.builds_started.append((workerforbuilder, buildrequests))
return defer.succeed(startBuildsForSucceeds)
self.bldr._startBuildFor = _startBuildFor
def assertBuildsStarted(self, exp):
# munge builds_started into a list of (worker, [brids])
builds_started = [
(wrk.name, [br.id for br in buildreqs]) for (wrk, buildreqs) in self.builds_started
]
self.assertEqual(sorted(builds_started), sorted(exp))
def setWorkerForBuilders(self, workerforbuilders):
"""C{workerforbuilders} maps name : available"""
self.bldr.workers = []
for name, avail in workerforbuilders.items():
wfb = mock.Mock(spec=['isAvailable'], name=name)
wfb.name = name
wfb.isAvailable.return_value = avail
self.bldr.workers.append(wfb)
# services
@defer.inlineCallbacks
def test_maybeStartBuild_builder_stopped(self):
yield self.makeBuilder()
# this will cause an exception if maybeStartBuild tries to start
self.bldr.workers = None
# so we just hope this does not fail
yield self.bldr.stopService()
started = yield self.bldr.maybeStartBuild(None, [])
self.assertEqual(started, False)
# maybeStartBuild
def _makeMocks(self):
worker = mock.Mock()
worker.name = 'worker'
buildrequest = mock.Mock()
buildrequest.id = 10
buildrequests = [buildrequest]
return worker, buildrequests
@defer.inlineCallbacks
def test_maybeStartBuild(self):
yield self.makeBuilder()
worker, buildrequests = self._makeMocks()
started = yield self.bldr.maybeStartBuild(worker, buildrequests)
self.assertEqual(started, True)
self.assertBuildsStarted([('worker', [10])])
@defer.inlineCallbacks
def test_maybeStartBuild_failsToStart(self):
yield self.makeBuilder(startBuildsForSucceeds=False)
worker, buildrequests = self._makeMocks()
started = yield self.bldr.maybeStartBuild(worker, buildrequests)
self.assertEqual(started, False)
self.assertBuildsStarted([('worker', [10])])
@defer.inlineCallbacks
def do_test_getCollapseRequestsFn(self, builder_param=None, global_param=None, expected=0):
def cble():
pass
builder_param = cble if builder_param == 'callable' else builder_param
global_param = cble if global_param == 'callable' else global_param
# omit the constructor parameter if None was given
if builder_param is None:
yield self.makeBuilder()
else:
yield self.makeBuilder(collapseRequests=builder_param)
self.master.config.collapseRequests = global_param
fn = self.bldr.getCollapseRequestsFn()
if fn == builder.Builder._defaultCollapseRequestFn:
fn = "default"
elif fn is cble:
fn = 'callable'
self.assertEqual(fn, expected)
def test_getCollapseRequestsFn_defaults(self):
self.do_test_getCollapseRequestsFn(None, None, "default")
def test_getCollapseRequestsFn_global_True(self):
self.do_test_getCollapseRequestsFn(None, True, "default")
def test_getCollapseRequestsFn_global_False(self):
self.do_test_getCollapseRequestsFn(None, False, None)
def test_getCollapseRequestsFn_global_function(self):
self.do_test_getCollapseRequestsFn(None, 'callable', 'callable')
def test_getCollapseRequestsFn_builder_True(self):
self.do_test_getCollapseRequestsFn(True, False, "default")
def test_getCollapseRequestsFn_builder_False(self):
self.do_test_getCollapseRequestsFn(False, True, None)
def test_getCollapseRequestsFn_builder_function(self):
self.do_test_getCollapseRequestsFn('callable', None, 'callable')
# canStartBuild
@defer.inlineCallbacks
def test_canStartBuild_no_constraints(self):
yield self.makeBuilder()
wfb = mock.Mock()
wfb.worker = FakeWorker('worker')
startable = yield self.bldr.canStartBuild(wfb, 100)
self.assertEqual(startable, True)
startable = yield self.bldr.canStartBuild(wfb, 101)
self.assertEqual(startable, True)
@defer.inlineCallbacks
def test_canStartBuild_config_canStartBuild_returns_value(self):
yield self.makeBuilder()
def canStartBuild(bldr, worker, breq):
return breq == 100
canStartBuild = mock.Mock(side_effect=canStartBuild)
self.bldr.config.canStartBuild = canStartBuild
wfb = mock.Mock()
wfb.worker = FakeWorker('worker')
startable = yield self.bldr.canStartBuild(wfb, 100)
self.assertEqual(startable, True)
canStartBuild.assert_called_with(self.bldr, wfb, 100)
canStartBuild.reset_mock()
startable = yield self.bldr.canStartBuild(wfb, 101)
self.assertEqual(startable, False)
canStartBuild.assert_called_with(self.bldr, wfb, 101)
canStartBuild.reset_mock()
@defer.inlineCallbacks
def test_canStartBuild_config_canStartBuild_returns_deferred(self):
yield self.makeBuilder()
wfb = mock.Mock()
wfb.worker = FakeWorker('worker')
def canStartBuild(bldr, wfb, breq):
return defer.succeed(breq == 100)
canStartBuild = mock.Mock(side_effect=canStartBuild)
self.bldr.config.canStartBuild = canStartBuild
startable = yield self.bldr.canStartBuild(wfb, 100)
self.assertEqual(startable, True)
canStartBuild.assert_called_with(self.bldr, wfb, 100)
canStartBuild.reset_mock()
startable = yield self.bldr.canStartBuild(wfb, 101)
self.assertEqual(startable, False)
canStartBuild.assert_called_with(self.bldr, wfb, 101)
canStartBuild.reset_mock()
@defer.inlineCallbacks
def test_canStartBuild_cant_acquire_locks_but_no_locks(self):
yield self.makeBuilder()
self.bldr.config.locks = [mock.Mock]
self.bldr.botmaster.getLockFromLockAccesses = mock.Mock(return_value=[])
self.bldr._can_acquire_locks = lambda _: False
wfb = mock.Mock()
wfb.worker = FakeWorker('worker')
startable = yield self.bldr.canStartBuild(wfb, 100)
self.assertEqual(startable, True)
@defer.inlineCallbacks
def test_canStartBuild_with_locks(self):
yield self.makeBuilder()
self.bldr.config.locks = [mock.Mock]
self.bldr.botmaster.getLockFromLockAccesses = mock.Mock(
return_value=[(mock.Mock(), mock.Mock())]
)
self.bldr._can_acquire_locks = lambda _: False
wfb = mock.Mock()
wfb.worker = FakeWorker('worker')
startable = yield self.bldr.canStartBuild(wfb, 100)
self.assertEqual(startable, False)
@defer.inlineCallbacks
def test_canStartBuild_with_renderable_locks(self):
yield self.makeBuilder()
self.bldr.botmaster.getLockFromLockAccesses = mock.Mock(
return_value=[(mock.Mock(), mock.Mock())]
)
renderedLocks = [False]
@renderer
def rendered_locks(props):
renderedLocks[0] = True
return [mock.Mock()]
self.bldr.config.locks = rendered_locks
self.bldr._can_acquire_locks = lambda _: False
wfb = mock.Mock()
wfb.worker = FakeWorker('worker')
with mock.patch(
'buildbot.process.build.Build.setup_properties_known_before_build_starts', mock.Mock()
):
startable = yield self.bldr.canStartBuild(wfb, 100)
self.assertEqual(startable, False)
self.assertTrue(renderedLocks[0])
@defer.inlineCallbacks
def test_canStartBuild_with_incompatible_latent_worker(self):
yield self.makeBuilder()
wfb = mock.Mock()
wfb.worker = FakeLatentWorker(is_compatible_with_build=False)
with mock.patch(
'buildbot.process.build.Build.setup_properties_known_before_build_starts', mock.Mock()
):
startable = yield self.bldr.canStartBuild(wfb, 100)
self.assertFalse(startable)
@defer.inlineCallbacks
def test_canStartBuild_with_renderable_locks_with_compatible_latent_worker(self):
yield self.makeBuilder()
self.bldr.config.locks = [mock.Mock]
self.bldr.botmaster.getLockFromLockAccesses = mock.Mock(
return_value=[(mock.Mock(), mock.Mock())]
)
rendered_locks = [False]
@renderer
def locks_renderer(props):
rendered_locks[0] = True
return [mock.Mock()]
self.bldr.config.locks = locks_renderer
self.bldr._can_acquire_locks = lambda _: False
wfb = mock.Mock()
wfb.worker = FakeLatentWorker(is_compatible_with_build=True)
with mock.patch(
'buildbot.process.build.Build.setup_properties_known_before_build_starts', mock.Mock()
):
startable = yield self.bldr.canStartBuild(wfb, 100)
self.assertEqual(startable, False)
self.assertFalse(startable)
self.assertTrue(rendered_locks[0])
@defer.inlineCallbacks
def test_canStartBuild_enforceChosenWorker(self):
"""enforceChosenWorker rejects and accepts builds"""
yield self.makeBuilder()
self.bldr.config.canStartBuild = builder.enforceChosenWorker
workerforbuilder = mock.Mock()
workerforbuilder.worker = FakeWorker('worker5')
breq = mock.Mock()
# no worker requested
breq.properties = {}
result = yield self.bldr.canStartBuild(workerforbuilder, breq)
self.assertIdentical(True, result)
# worker requested as the right one
breq.properties = {'workername': 'worker5'}
result = yield self.bldr.canStartBuild(workerforbuilder, breq)
self.assertIdentical(True, result)
# worker requested as the wrong one
breq.properties = {'workername': 'worker4'}
result = yield self.bldr.canStartBuild(workerforbuilder, breq)
self.assertIdentical(False, result)
# worker set to non string value gets skipped
breq.properties = {'workername': 0}
result = yield self.bldr.canStartBuild(workerforbuilder, breq)
self.assertIdentical(True, result)
# other methods
@defer.inlineCallbacks
def test_getBuilderId(self):
self.factory = factory.BuildFactory()
self.master = yield fakemaster.make_master(self, wantData=True)
# only include the necessary required config, plus user-requested
self.bldr = builder.Builder('bldr')
self.bldr.master = self.master
self.master.data.updates.findBuilderId = fbi = mock.Mock()
fbi.return_value = defer.succeed(13)
builderid = yield self.bldr.getBuilderId()
self.assertEqual(builderid, 13)
fbi.assert_called_with('bldr')
fbi.reset_mock()
builderid = yield self.bldr.getBuilderId()
self.assertEqual(builderid, 13)
fbi.assert_not_called()
@defer.inlineCallbacks
def test_expectations_deprecated(self):
yield self.makeBuilder()
with assertProducesWarning(
Warning, message_pattern="'Builder.expectations' is deprecated."
):
deprecated = self.bldr.expectations
self.assertIdentical(deprecated, None)
@defer.inlineCallbacks
def test_defaultProperties(self):
props = Properties()
props.setProperty('foo', 1, 'Scheduler')
props.setProperty('bar', 'bleh', 'Change')
yield self.makeBuilder(defaultProperties={'bar': 'onoes', 'cuckoo': 42})
yield self.bldr.setup_properties(props)
self.assertEqual(props.getProperty('bar'), 'bleh')
self.assertEqual(props.getProperty('cuckoo'), 42)
class TestGetBuilderId(TestReactorMixin, BuilderMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setUpBuilderMixin()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_getBuilderId(self):
# noReconfig because reconfigService calls getBuilderId, and we haven't
# set up the mock findBuilderId yet.
yield self.makeBuilder(name='b1', noReconfig=True)
fbi = self.master.data.updates.findBuilderId = mock.Mock(name='fbi')
fbi.side_effect = lambda name: defer.succeed(13)
# call twice..
self.assertEqual((yield self.bldr.getBuilderId()), 13)
self.assertEqual((yield self.bldr.getBuilderId()), 13)
# and see that fbi was only called once
fbi.assert_called_once_with('b1')
# check that the name was unicodified
arg = fbi.mock_calls[0][1][0]
self.assertIsInstance(arg, str)
class TestGetOldestRequestTime(TestReactorMixin, BuilderMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setUpBuilderMixin()
# a collection of rows that would otherwise clutter up every test
master_id = fakedb.FakeDBConnector.MASTER_ID
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(buildsetid=11, sourcestampid=21),
fakedb.Builder(id=77, name='bldr1'),
fakedb.Builder(id=78, name='bldr2'),
fakedb.Builder(id=182, name='foo@bar'),
fakedb.BuildRequest(id=111, submitted_at=1000, builderid=77, buildsetid=11),
fakedb.BuildRequest(id=222, submitted_at=2000, builderid=77, buildsetid=11),
fakedb.BuildRequestClaim(brid=222, masterid=master_id, claimed_at=2001),
fakedb.BuildRequest(id=333, submitted_at=3000, builderid=77, buildsetid=11),
fakedb.BuildRequest(id=444, submitted_at=2500, builderid=78, buildsetid=11),
fakedb.BuildRequestClaim(brid=444, masterid=master_id, claimed_at=2501),
fakedb.BuildRequest(id=555, submitted_at=2800, builderid=182, buildsetid=11),
]
yield self.db.insert_test_data(self.base_rows)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_gort_unclaimed(self):
yield self.makeBuilder(name='bldr1')
rqtime = yield self.bldr.getOldestRequestTime()
self.assertEqual(rqtime, epoch2datetime(1000))
@defer.inlineCallbacks
def test_gort_bldr_name_not_identifier(self):
# this is a regression test for #2940
yield self.makeBuilder(name='foo@bar')
rqtime = yield self.bldr.getOldestRequestTime()
self.assertEqual(rqtime, epoch2datetime(2800))
@defer.inlineCallbacks
def test_gort_all_claimed(self):
yield self.makeBuilder(name='bldr2')
rqtime = yield self.bldr.getOldestRequestTime()
self.assertEqual(rqtime, None)
class TestGetNewestCompleteTime(TestReactorMixin, BuilderMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setUpBuilderMixin()
# a collection of rows that would otherwise clutter up every test
master_id = fakedb.FakeDBConnector.MASTER_ID
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(buildsetid=11, sourcestampid=21),
fakedb.Builder(id=77, name='bldr1'),
fakedb.Builder(id=78, name='bldr2'),
fakedb.BuildRequest(
id=111, submitted_at=1000, complete=1, complete_at=1000, builderid=77, buildsetid=11
),
fakedb.BuildRequest(
id=222, submitted_at=2000, complete=1, complete_at=4000, builderid=77, buildsetid=11
),
fakedb.BuildRequest(
id=333, submitted_at=3000, complete=1, complete_at=3000, builderid=77, buildsetid=11
),
fakedb.BuildRequest(id=444, submitted_at=2500, builderid=78, buildsetid=11),
fakedb.BuildRequestClaim(brid=444, masterid=master_id, claimed_at=2501),
]
yield self.db.insert_test_data(self.base_rows)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_gnct_completed(self):
yield self.makeBuilder(name='bldr1')
rqtime = yield self.bldr.getNewestCompleteTime()
self.assertEqual(rqtime, epoch2datetime(4000))
@defer.inlineCallbacks
def test_gnct_no_completed(self):
yield self.makeBuilder(name='bldr2')
rqtime = yield self.bldr.getNewestCompleteTime()
self.assertEqual(rqtime, None)
class TestGetHighestPriority(TestReactorMixin, BuilderMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setUpBuilderMixin()
# a collection of rows that would otherwise clutter up every test
master_id = fakedb.FakeDBConnector.MASTER_ID
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(buildsetid=11, sourcestampid=21),
fakedb.Builder(id=77, name='bldr1'),
fakedb.Builder(id=78, name='bldr2'),
fakedb.BuildRequest(id=111, submitted_at=1000, builderid=77, buildsetid=11, priority=0),
fakedb.BuildRequest(
id=222, submitted_at=2000, builderid=77, buildsetid=11, priority=10
),
fakedb.BuildRequestClaim(brid=222, masterid=master_id, claimed_at=2001),
fakedb.BuildRequest(id=333, submitted_at=3000, builderid=77, buildsetid=11, priority=5),
fakedb.BuildRequest(id=444, submitted_at=3001, builderid=77, buildsetid=11, priority=3),
fakedb.BuildRequest(id=555, submitted_at=2500, builderid=78, buildsetid=11),
fakedb.BuildRequestClaim(brid=555, masterid=master_id, claimed_at=2501),
]
yield self.db.insert_test_data(self.base_rows)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_ghp_unclaimed(self):
yield self.makeBuilder(name='bldr1')
priority = yield self.bldr.get_highest_priority()
self.assertEqual(priority, 5)
@defer.inlineCallbacks
def test_ghp_all_claimed(self):
yield self.makeBuilder(name='bldr2')
priority = yield self.bldr.get_highest_priority()
self.assertEqual(priority, None)
class TestReconfig(TestReactorMixin, BuilderMixin, unittest.TestCase):
"""Tests that a reconfig properly updates all attributes"""
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setUpBuilderMixin()
yield self.db.insert_test_data([
fakedb.Project(id=301, name='old_project'),
fakedb.Project(id=302, name='new_project'),
])
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_reconfig(self):
yield self.makeBuilder(description="Old", project="old_project", tags=["OldTag"])
new_builder_config = config.BuilderConfig(**self.config_args)
new_builder_config.description = "New"
new_builder_config.project = "new_project"
new_builder_config.tags = ["NewTag"]
mastercfg = MasterConfig()
mastercfg.builders = [new_builder_config]
yield self.bldr.reconfigServiceWithBuildbotConfig(mastercfg)
# check that the reconfig grabbed a builderid
self.assertIsNotNone(self.bldr._builderid)
builder_dict = yield self.master.data.get(('builders', self.bldr._builderid))
self.assertEqual(builder_dict['description'], 'New')
self.assertEqual(builder_dict['projectid'], 302)
self.assertEqual(builder_dict['tags'], ['NewTag'])
self.assertIdentical(self.bldr.config, new_builder_config)
@parameterized.expand([
('only_description', 'New', 'old_project', ['OldTag'], 301),
('only_project', 'Old', 'new_project', ['OldTag'], 302),
('only_tags', 'Old', 'old_project', ['NewTag'], 301),
])
@defer.inlineCallbacks
def test_reconfig_changed(self, name, new_desc, new_project, new_tags, expect_project_id):
yield self.makeBuilder(description="Old", project='old_project', tags=["OldTag"])
new_builder_config = config.BuilderConfig(**self.config_args)
new_builder_config.description = new_desc
new_builder_config.tags = new_tags
new_builder_config.project = new_project
mastercfg = MasterConfig()
mastercfg.builders = [new_builder_config]
builder_updates = []
self.master.data.updates.updateBuilderInfo = (
lambda builderid,
desc,
desc_format,
desc_html,
projectid,
tags: builder_updates.append((builderid, desc, desc_format, desc_html, projectid, tags))
)
yield self.bldr.reconfigServiceWithBuildbotConfig(mastercfg)
self.assertEqual(builder_updates, [(1, new_desc, None, None, expect_project_id, new_tags)])
@defer.inlineCallbacks
def test_does_not_reconfig_identical(self):
yield self.makeBuilder(description="Old", project="old_project", tags=["OldTag"])
new_builder_config = config.BuilderConfig(**self.config_args)
mastercfg = MasterConfig()
mastercfg.builders = [new_builder_config]
builder_updates = []
self.master.data.updates.updateBuilderInfo = (
lambda builderid,
desc,
desc_format,
desc_html,
projectid,
tags: builder_updates.append((builderid, desc, desc_format, desc_html, projectid, tags))
)
yield self.bldr.reconfigServiceWithBuildbotConfig(mastercfg)
self.assertEqual(builder_updates, [])
| 27,027 | Python | .py | 575 | 38.295652 | 100 | 0.677849 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,449 | test_properties.py | buildbot_buildbot/master/buildbot/test/unit/process/test_properties.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from copy import deepcopy
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from zope.interface import implementer
from buildbot.interfaces import IRenderable
from buildbot.process.buildrequest import TempChange
from buildbot.process.buildrequest import TempSourceStamp
from buildbot.process.properties import FlattenList
from buildbot.process.properties import Interpolate
from buildbot.process.properties import Properties
from buildbot.process.properties import PropertiesMixin
from buildbot.process.properties import Property
from buildbot.process.properties import Transform
from buildbot.process.properties import WithProperties
from buildbot.process.properties import _Lazy
from buildbot.process.properties import _Lookup
from buildbot.process.properties import _SourceStampDict
from buildbot.process.properties import renderer
from buildbot.test.fake.fakebuild import FakeBuild
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.properties import ConstantRenderable
class FakeSource:
def __init__(self):
self.branch = None
self.codebase = ''
self.project = ''
self.repository = ''
self.revision = None
def asDict(self):
ds = {
'branch': self.branch,
'codebase': self.codebase,
'project': self.project,
'repository': self.repository,
'revision': self.revision,
}
return ds
@implementer(IRenderable)
class DeferredRenderable:
def __init__(self):
self.d = defer.Deferred()
def getRenderingFor(self, build):
return self.d
def callback(self, value):
self.d.callback(value)
class TestPropertyMap(unittest.TestCase):
"""
Test the behavior of PropertyMap, using the external interface
provided by WithProperties.
"""
def setUp(self):
self.props = Properties(
prop_str='a-string',
prop_none=None,
prop_list=['a', 'b'],
prop_zero=0,
prop_one=1,
prop_false=False,
prop_true=True,
prop_empty='',
)
self.build = FakeBuild(props=self.props)
@defer.inlineCallbacks
def doTestSimpleWithProperties(self, fmtstring, expect, **kwargs):
res = yield self.build.render(WithProperties(fmtstring, **kwargs))
self.assertEqual(res, f"{expect}")
def testSimpleStr(self):
return self.doTestSimpleWithProperties('%(prop_str)s', 'a-string')
def testSimpleNone(self):
# None is special-cased to become an empty string
return self.doTestSimpleWithProperties('%(prop_none)s', '')
def testSimpleList(self):
return self.doTestSimpleWithProperties('%(prop_list)s', ['a', 'b'])
def testSimpleZero(self):
return self.doTestSimpleWithProperties('%(prop_zero)s', 0)
def testSimpleOne(self):
return self.doTestSimpleWithProperties('%(prop_one)s', 1)
def testSimpleFalse(self):
return self.doTestSimpleWithProperties('%(prop_false)s', False)
def testSimpleTrue(self):
return self.doTestSimpleWithProperties('%(prop_true)s', True)
def testSimpleEmpty(self):
return self.doTestSimpleWithProperties('%(prop_empty)s', '')
def testSimpleUnset(self):
d = self.build.render(WithProperties('%(prop_nosuch)s'))
return self.assertFailure(d, KeyError)
def testColonMinusSet(self):
return self.doTestSimpleWithProperties('%(prop_str:-missing)s', 'a-string')
def testColonMinusNone(self):
# None is special-cased here, too
return self.doTestSimpleWithProperties('%(prop_none:-missing)s', '')
def testColonMinusZero(self):
return self.doTestSimpleWithProperties('%(prop_zero:-missing)s', 0)
def testColonMinusOne(self):
return self.doTestSimpleWithProperties('%(prop_one:-missing)s', 1)
def testColonMinusFalse(self):
return self.doTestSimpleWithProperties('%(prop_false:-missing)s', False)
def testColonMinusTrue(self):
return self.doTestSimpleWithProperties('%(prop_true:-missing)s', True)
def testColonMinusEmpty(self):
return self.doTestSimpleWithProperties('%(prop_empty:-missing)s', '')
def testColonMinusUnset(self):
return self.doTestSimpleWithProperties('%(prop_nosuch:-missing)s', 'missing')
def testColonTildeSet(self):
return self.doTestSimpleWithProperties('%(prop_str:~missing)s', 'a-string')
def testColonTildeNone(self):
# None is special-cased *differently* for ~:
return self.doTestSimpleWithProperties('%(prop_none:~missing)s', 'missing')
def testColonTildeZero(self):
return self.doTestSimpleWithProperties('%(prop_zero:~missing)s', 'missing')
def testColonTildeOne(self):
return self.doTestSimpleWithProperties('%(prop_one:~missing)s', 1)
def testColonTildeFalse(self):
return self.doTestSimpleWithProperties('%(prop_false:~missing)s', 'missing')
def testColonTildeTrue(self):
return self.doTestSimpleWithProperties('%(prop_true:~missing)s', True)
def testColonTildeEmpty(self):
return self.doTestSimpleWithProperties('%(prop_empty:~missing)s', 'missing')
def testColonTildeUnset(self):
return self.doTestSimpleWithProperties('%(prop_nosuch:~missing)s', 'missing')
def testColonPlusSet(self):
return self.doTestSimpleWithProperties('%(prop_str:+present)s', 'present')
def testColonPlusNone(self):
return self.doTestSimpleWithProperties('%(prop_none:+present)s', 'present')
def testColonPlusZero(self):
return self.doTestSimpleWithProperties('%(prop_zero:+present)s', 'present')
def testColonPlusOne(self):
return self.doTestSimpleWithProperties('%(prop_one:+present)s', 'present')
def testColonPlusFalse(self):
return self.doTestSimpleWithProperties('%(prop_false:+present)s', 'present')
def testColonPlusTrue(self):
return self.doTestSimpleWithProperties('%(prop_true:+present)s', 'present')
def testColonPlusEmpty(self):
return self.doTestSimpleWithProperties('%(prop_empty:+present)s', 'present')
def testColonPlusUnset(self):
return self.doTestSimpleWithProperties('%(prop_nosuch:+present)s', '')
@defer.inlineCallbacks
def testClearTempValues(self):
yield self.doTestSimpleWithProperties('', '', prop_temp=lambda b: 'present')
yield self.doTestSimpleWithProperties('%(prop_temp:+present)s', '')
def testTempValue(self):
return self.doTestSimpleWithProperties(
'%(prop_temp)s', 'present', prop_temp=lambda b: 'present'
)
def testTempValueOverrides(self):
return self.doTestSimpleWithProperties('%(prop_one)s', 2, prop_one=lambda b: 2)
def testTempValueColonMinusSet(self):
return self.doTestSimpleWithProperties('%(prop_one:-missing)s', 2, prop_one=lambda b: 2)
def testTempValueColonMinusUnset(self):
return self.doTestSimpleWithProperties(
'%(prop_nosuch:-missing)s', 'temp', prop_nosuch=lambda b: 'temp'
)
def testTempValueColonTildeTrueSet(self):
return self.doTestSimpleWithProperties(
'%(prop_false:~nontrue)s', 'temp', prop_false=lambda b: 'temp'
)
def testTempValueColonTildeTrueUnset(self):
return self.doTestSimpleWithProperties(
'%(prop_nosuch:~nontrue)s', 'temp', prop_nosuch=lambda b: 'temp'
)
def testTempValueColonTildeFalseFalse(self):
return self.doTestSimpleWithProperties(
'%(prop_false:~nontrue)s', 'nontrue', prop_false=lambda b: False
)
def testTempValueColonTildeTrueFalse(self):
return self.doTestSimpleWithProperties(
'%(prop_true:~nontrue)s', True, prop_true=lambda b: False
)
def testTempValueColonTildeNoneFalse(self):
return self.doTestSimpleWithProperties(
'%(prop_nosuch:~nontrue)s', 'nontrue', prop_nosuch=lambda b: False
)
def testTempValueColonTildeFalseZero(self):
return self.doTestSimpleWithProperties(
'%(prop_false:~nontrue)s', 'nontrue', prop_false=lambda b: 0
)
def testTempValueColonTildeTrueZero(self):
return self.doTestSimpleWithProperties(
'%(prop_true:~nontrue)s', True, prop_true=lambda b: 0
)
def testTempValueColonTildeNoneZero(self):
return self.doTestSimpleWithProperties(
'%(prop_nosuch:~nontrue)s', 'nontrue', prop_nosuch=lambda b: 0
)
def testTempValueColonTildeFalseBlank(self):
return self.doTestSimpleWithProperties(
'%(prop_false:~nontrue)s', 'nontrue', prop_false=lambda b: ''
)
def testTempValueColonTildeTrueBlank(self):
return self.doTestSimpleWithProperties(
'%(prop_true:~nontrue)s', True, prop_true=lambda b: ''
)
def testTempValueColonTildeNoneBlank(self):
return self.doTestSimpleWithProperties(
'%(prop_nosuch:~nontrue)s', 'nontrue', prop_nosuch=lambda b: ''
)
def testTempValuePlusSetSet(self):
return self.doTestSimpleWithProperties('%(prop_one:+set)s', 'set', prop_one=lambda b: 2)
def testTempValuePlusUnsetSet(self):
return self.doTestSimpleWithProperties(
'%(prop_nosuch:+set)s', 'set', prop_nosuch=lambda b: 1
)
class TestInterpolateConfigure(unittest.TestCase, ConfigErrorsMixin):
"""
Test that Interpolate reports errors in the interpolation string
at configure time.
"""
def test_invalid_args_and_kwargs(self):
with self.assertRaisesConfigError("Interpolate takes either positional"):
Interpolate("%s %(foo)s", 1, foo=2)
def test_invalid_selector(self):
with self.assertRaisesConfigError("invalid Interpolate selector 'garbage'"):
Interpolate("%(garbage:test)s")
def test_no_selector(self):
with self.assertRaisesConfigError(
"invalid Interpolate substitution without selector 'garbage'"
):
Interpolate("%(garbage)s")
def test_invalid_default_type(self):
with self.assertRaisesConfigError("invalid Interpolate default type '@'"):
Interpolate("%(prop:some_prop:@wacky)s")
def test_nested_invalid_selector(self):
with self.assertRaisesConfigError("invalid Interpolate selector 'garbage'"):
Interpolate("%(prop:some_prop:~%(garbage:test)s)s")
def test_colon_ternary_missing_delimeter(self):
with self.assertRaisesConfigError(
"invalid Interpolate ternary expression 'one' with delimiter ':'"
):
Interpolate("echo '%(prop:P:?:one)s'")
def test_colon_ternary_paren_delimiter(self):
with self.assertRaisesConfigError(
"invalid Interpolate ternary expression 'one(:)' with delimiter ':'"
):
Interpolate("echo '%(prop:P:?:one(:))s'")
def test_colon_ternary_hash_bad_delimeter(self):
with self.assertRaisesConfigError(
"invalid Interpolate ternary expression 'one' with delimiter '|'"
):
Interpolate("echo '%(prop:P:#?|one)s'")
def test_prop_invalid_character(self):
with self.assertRaisesConfigError(
"Property name must be alphanumeric for prop Interpolation 'a+a'"
):
Interpolate("echo '%(prop:a+a)s'")
def test_kw_invalid_character(self):
with self.assertRaisesConfigError(
"Keyword must be alphanumeric for kw Interpolation 'a+a'"
):
Interpolate("echo '%(kw:a+a)s'")
def test_src_codebase_invalid_character(self):
with self.assertRaisesConfigError(
"Codebase must be alphanumeric for src Interpolation 'a+a:a'"
):
Interpolate("echo '%(src:a+a:a)s'")
def test_src_attr_invalid_character(self):
with self.assertRaisesConfigError(
"Attribute must be alphanumeric for src Interpolation 'a:a+a'"
):
Interpolate("echo '%(src:a:a+a)s'")
def test_src_missing_attr(self):
with self.assertRaisesConfigError("Must specify both codebase and attr"):
Interpolate("echo '%(src:a)s'")
class TestInterpolatePositional(unittest.TestCase):
def setUp(self):
self.props = Properties()
self.build = FakeBuild(props=self.props)
@defer.inlineCallbacks
def test_string(self):
command = Interpolate("test %s", "one fish")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "test one fish")
@defer.inlineCallbacks
def test_twoString(self):
command = Interpolate("test %s, %s", "one fish", "two fish")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "test one fish, two fish")
def test_deferred(self):
renderable = DeferredRenderable()
command = Interpolate("echo '%s'", renderable)
d = self.build.render(command)
d.addCallback(self.assertEqual, "echo 'red fish'")
renderable.callback("red fish")
return d
@defer.inlineCallbacks
def test_renderable(self):
self.props.setProperty("buildername", "blue fish", "test")
command = Interpolate("echo '%s'", Property("buildername"))
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'blue fish'")
class TestInterpolateProperties(unittest.TestCase):
def setUp(self):
self.props = Properties()
self.build = FakeBuild(props=self.props)
@defer.inlineCallbacks
def test_properties(self):
self.props.setProperty("buildername", "winbld", "test")
command = Interpolate("echo buildby-%(prop:buildername)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo buildby-winbld")
@defer.inlineCallbacks
def test_properties_newline(self):
self.props.setProperty("buildername", "winbld", "test")
command = Interpolate("aa\n%(prop:buildername)s\nbb")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "aa\nwinbld\nbb")
@defer.inlineCallbacks
def test_property_not_set(self):
command = Interpolate("echo buildby-%(prop:buildername)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo buildby-")
@defer.inlineCallbacks
def test_property_colon_minus(self):
command = Interpolate("echo buildby-%(prop:buildername:-blddef)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo buildby-blddef")
@defer.inlineCallbacks
def test_deepcopy(self):
# After a deepcopy, Interpolate instances used to lose track
# that they didn't have a ``hasKey`` value
# see http://trac.buildbot.net/ticket/3505
self.props.setProperty("buildername", "linux4", "test")
command = deepcopy(Interpolate("echo buildby-%(prop:buildername:-blddef)s"))
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo buildby-linux4")
@defer.inlineCallbacks
def test_property_colon_tilde_true(self):
self.props.setProperty("buildername", "winbld", "test")
command = Interpolate("echo buildby-%(prop:buildername:~blddef)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo buildby-winbld")
@defer.inlineCallbacks
def test_property_colon_tilde_false(self):
self.props.setProperty("buildername", "", "test")
command = Interpolate("echo buildby-%(prop:buildername:~blddef)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo buildby-blddef")
@defer.inlineCallbacks
def test_property_colon_plus(self):
self.props.setProperty("project", "proj1", "test")
command = Interpolate("echo %(prop:project:+projectdefined)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo projectdefined")
@defer.inlineCallbacks
def test_nested_property(self):
self.props.setProperty("project", "so long!", "test")
command = Interpolate("echo '%(prop:missing:~%(prop:project)s)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'so long!'")
@defer.inlineCallbacks
def test_property_substitute_recursively(self):
self.props.setProperty("project", "proj1", "test")
command = Interpolate("echo '%(prop:no_such:-%(prop:project)s)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'proj1'")
@defer.inlineCallbacks
def test_property_colon_ternary_present(self):
self.props.setProperty("project", "proj1", "test")
command = Interpolate("echo %(prop:project:?:defined:missing)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo defined")
@defer.inlineCallbacks
def test_property_colon_ternary_missing(self):
command = Interpolate("echo %(prop:project:?|defined|missing)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo missing")
@defer.inlineCallbacks
def test_property_colon_ternary_hash_true(self):
self.props.setProperty("project", "winbld", "test")
command = Interpolate("echo buildby-%(prop:project:#?:T:F)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo buildby-T")
@defer.inlineCallbacks
def test_property_colon_ternary_hash_false(self):
self.props.setProperty("project", "", "test")
command = Interpolate("echo buildby-%(prop:project:#?|T|F)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo buildby-F")
@defer.inlineCallbacks
def test_property_colon_ternary_substitute_recursively_true(self):
self.props.setProperty("P", "present", "test")
self.props.setProperty("one", "proj1", "test")
self.props.setProperty("two", "proj2", "test")
command = Interpolate("echo '%(prop:P:?|%(prop:one)s|%(prop:two)s)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'proj1'")
@defer.inlineCallbacks
def test_property_colon_ternary_substitute_recursively_false(self):
self.props.setProperty("one", "proj1", "test")
self.props.setProperty("two", "proj2", "test")
command = Interpolate("echo '%(prop:P:?|%(prop:one)s|%(prop:two)s)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'proj2'")
@defer.inlineCallbacks
def test_property_colon_ternary_substitute_recursively_delimited_true(self):
self.props.setProperty("P", "present", "test")
self.props.setProperty("one", "proj1", "test")
self.props.setProperty("two", "proj2", "test")
command = Interpolate(
"echo '%(prop:P:?|%(prop:one:?|true|false)s|%(prop:two:?|false|true)s)s'"
)
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'true'")
@defer.inlineCallbacks
def test_property_colon_ternary_substitute_recursively_delimited_false(self):
self.props.setProperty("one", "proj1", "test")
self.props.setProperty("two", "proj2", "test")
command = Interpolate(
"echo '%(prop:P:?|%(prop:one:?|true|false)s|%(prop:two:?|false|true)s)s'"
)
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'false'")
class TestInterpolateSrc(unittest.TestCase):
def setUp(self):
self.props = Properties()
self.build = FakeBuild(props=self.props)
sa = FakeSource()
wfb = FakeSource()
sc = FakeSource()
sa.repository = 'cvs://A..'
sa.codebase = 'cbA'
sa.project = "Project"
self.build.sources['cbA'] = sa
wfb.repository = 'cvs://B..'
wfb.codebase = 'cbB'
wfb.project = "Project"
self.build.sources['cbB'] = wfb
sc.repository = 'cvs://C..'
sc.codebase = 'cbC'
sc.project = None
self.build.sources['cbC'] = sc
@defer.inlineCallbacks
def test_src(self):
command = Interpolate("echo %(src:cbB:repository)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://B..")
@defer.inlineCallbacks
def test_src_src(self):
command = Interpolate("echo %(src:cbB:repository)s %(src:cbB:project)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://B.. Project")
@defer.inlineCallbacks
def test_src_attr_empty(self):
command = Interpolate("echo %(src:cbC:project)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo ")
@defer.inlineCallbacks
def test_src_attr_codebase_notfound(self):
command = Interpolate("echo %(src:unknown_codebase:project)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo ")
@defer.inlineCallbacks
def test_src_colon_plus_false(self):
command = Interpolate("echo '%(src:cbD:project:+defaultrepo)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo ''")
@defer.inlineCallbacks
def test_src_colon_plus_true(self):
command = Interpolate("echo '%(src:cbB:project:+defaultrepo)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'defaultrepo'")
@defer.inlineCallbacks
def test_src_colon_minus(self):
command = Interpolate("echo %(src:cbB:nonattr:-defaultrepo)s")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo defaultrepo")
@defer.inlineCallbacks
def test_src_colon_minus_false(self):
command = Interpolate("echo '%(src:cbC:project:-noproject)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo ''")
@defer.inlineCallbacks
def test_src_colon_minus_true(self):
command = Interpolate("echo '%(src:cbB:project:-noproject)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'Project'")
@defer.inlineCallbacks
def test_src_colon_minus_codebase_notfound(self):
command = Interpolate("echo '%(src:unknown_codebase:project:-noproject)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'noproject'")
@defer.inlineCallbacks
def test_src_colon_tilde_true(self):
command = Interpolate("echo '%(src:cbB:project:~noproject)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'Project'")
@defer.inlineCallbacks
def test_src_colon_tilde_false(self):
command = Interpolate("echo '%(src:cbC:project:~noproject)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'noproject'")
@defer.inlineCallbacks
def test_src_colon_tilde_false_src_as_replacement(self):
command = Interpolate("echo '%(src:cbC:project:~%(src:cbA:project)s)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'Project'")
@defer.inlineCallbacks
def test_src_colon_tilde_codebase_notfound(self):
command = Interpolate("echo '%(src:unknown_codebase:project:~noproject)s'")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'noproject'")
class TestInterpolateKwargs(unittest.TestCase):
def setUp(self):
self.props = Properties()
self.build = FakeBuild(props=self.props)
sa = FakeSource()
sa.repository = 'cvs://A..'
sa.codebase = 'cbA'
sa.project = None
sa.branch = "default"
self.build.sources['cbA'] = sa
@defer.inlineCallbacks
def test_kwarg(self):
command = Interpolate("echo %(kw:repository)s", repository="cvs://A..")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://A..")
@defer.inlineCallbacks
def test_kwarg_kwarg(self):
command = Interpolate(
"echo %(kw:repository)s %(kw:branch)s", repository="cvs://A..", branch="default"
)
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://A.. default")
@defer.inlineCallbacks
def test_kwarg_not_mapped(self):
command = Interpolate("echo %(kw:repository)s", project="projectA")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo ")
@defer.inlineCallbacks
def test_kwarg_colon_minus_not_available(self):
command = Interpolate("echo %(kw:repository)s", project="projectA")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo ")
@defer.inlineCallbacks
def test_kwarg_colon_minus_not_available_default(self):
command = Interpolate("echo %(kw:repository:-cvs://A..)s", project="projectA")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://A..")
@defer.inlineCallbacks
def test_kwarg_colon_minus_available(self):
command = Interpolate("echo %(kw:repository:-cvs://A..)s", repository="cvs://B..")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://B..")
@defer.inlineCallbacks
def test_kwarg_colon_tilde_true(self):
command = Interpolate("echo %(kw:repository:~cvs://B..)s", repository="cvs://A..")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://A..")
@defer.inlineCallbacks
def test_kwarg_colon_tilde_false(self):
command = Interpolate("echo %(kw:repository:~cvs://B..)s", repository="")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://B..")
@defer.inlineCallbacks
def test_kwarg_colon_tilde_none(self):
command = Interpolate("echo %(kw:repository:~cvs://B..)s", repository=None)
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://B..")
@defer.inlineCallbacks
def test_kwarg_colon_plus_false(self):
command = Interpolate("echo %(kw:repository:+cvs://B..)s", project="project")
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo ")
@defer.inlineCallbacks
def test_kwarg_colon_plus_true(self):
command = Interpolate("echo %(kw:repository:+cvs://B..)s", repository=None)
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo cvs://B..")
@defer.inlineCallbacks
def test_kwargs_colon_minus_false_src_as_replacement(self):
command = Interpolate("echo '%(kw:text:-%(src:cbA:branch)s)s'", notext='ddd')
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'default'")
@defer.inlineCallbacks
def test_kwargs_renderable(self):
command = Interpolate("echo '%(kw:test)s'", test=ConstantRenderable('testing'))
rendered = yield self.build.render(command)
self.assertEqual(rendered, "echo 'testing'")
def test_kwargs_deferred(self):
renderable = DeferredRenderable()
command = Interpolate("echo '%(kw:test)s'", test=renderable)
d = self.build.render(command)
d.addCallback(self.assertEqual, "echo 'testing'")
renderable.callback('testing')
def test_kwarg_deferred(self):
renderable = DeferredRenderable()
command = Interpolate("echo '%(kw:project)s'", project=renderable)
d = self.build.render(command)
d.addCallback(self.assertEqual, "echo 'testing'")
renderable.callback('testing')
def test_nested_kwarg_deferred(self):
renderable = DeferredRenderable()
command = Interpolate(
"echo '%(kw:missing:~%(kw:fishy)s)s'", missing=renderable, fishy="so long!"
)
d = self.build.render(command)
d.addCallback(self.assertEqual, "echo 'so long!'")
renderable.callback(False)
return d
class TestWithProperties(unittest.TestCase):
def setUp(self):
self.props = Properties()
self.build = FakeBuild(props=self.props)
def testInvalidParams(self):
with self.assertRaises(ValueError):
WithProperties("%s %(foo)s", 1, foo=2)
@defer.inlineCallbacks
def testBasic(self):
# test basic substitution with WithProperties
self.props.setProperty("revision", "47", "test")
command = WithProperties("build-%s.tar.gz", "revision")
res = yield self.build.render(command)
self.assertEqual(res, "build-47.tar.gz")
@defer.inlineCallbacks
def testDict(self):
# test dict-style substitution with WithProperties
self.props.setProperty("other", "foo", "test")
command = WithProperties("build-%(other)s.tar.gz")
res = yield self.build.render(command)
self.assertEqual(res, "build-foo.tar.gz")
@defer.inlineCallbacks
def testDictColonMinus(self):
# test dict-style substitution with WithProperties
self.props.setProperty("prop1", "foo", "test")
command = WithProperties("build-%(prop1:-empty)s-%(prop2:-empty)s.tar.gz")
res = yield self.build.render(command)
self.assertEqual(res, "build-foo-empty.tar.gz")
@defer.inlineCallbacks
def testDictColonPlus(self):
# test dict-style substitution with WithProperties
self.props.setProperty("prop1", "foo", "test")
command = WithProperties("build-%(prop1:+exists)s-%(prop2:+exists)s.tar.gz")
res = yield self.build.render(command)
self.assertEqual(res, "build-exists-.tar.gz")
@defer.inlineCallbacks
def testEmpty(self):
# None should render as ''
self.props.setProperty("empty", None, "test")
command = WithProperties("build-%(empty)s.tar.gz")
res = yield self.build.render(command)
self.assertEqual(res, "build-.tar.gz")
@defer.inlineCallbacks
def testRecursiveList(self):
self.props.setProperty("x", 10, "test")
self.props.setProperty("y", 20, "test")
command = [WithProperties("%(x)s %(y)s"), "and", WithProperties("%(y)s %(x)s")]
res = yield self.build.render(command)
self.assertEqual(res, ["10 20", "and", "20 10"])
@defer.inlineCallbacks
def testRecursiveTuple(self):
self.props.setProperty("x", 10, "test")
self.props.setProperty("y", 20, "test")
command = (WithProperties("%(x)s %(y)s"), "and", WithProperties("%(y)s %(x)s"))
res = yield self.build.render(command)
self.assertEqual(res, ("10 20", "and", "20 10"))
@defer.inlineCallbacks
def testRecursiveDict(self):
self.props.setProperty("x", 10, "test")
self.props.setProperty("y", 20, "test")
command = {WithProperties("%(x)s %(y)s"): WithProperties("%(y)s %(x)s")}
res = yield self.build.render(command)
self.assertEqual(res, {"10 20": "20 10"})
@defer.inlineCallbacks
def testLambdaSubst(self):
command = WithProperties('%(foo)s', foo=lambda _: 'bar')
res = yield self.build.render(command)
self.assertEqual(res, 'bar')
@defer.inlineCallbacks
def testLambdaHasattr(self):
command = WithProperties('%(foo)s', foo=lambda b: b.hasProperty('x') and 'x' or 'y')
res = yield self.build.render(command)
self.assertEqual(res, 'y')
@defer.inlineCallbacks
def testLambdaOverride(self):
self.props.setProperty('x', 10, 'test')
command = WithProperties('%(x)s', x=lambda _: 20)
res = yield self.build.render(command)
self.assertEqual(res, '20')
def testLambdaCallable(self):
with self.assertRaises(ValueError):
WithProperties('%(foo)s', foo='bar')
@defer.inlineCallbacks
def testLambdaUseExisting(self):
self.props.setProperty('x', 10, 'test')
self.props.setProperty('y', 20, 'test')
command = WithProperties(
'%(z)s', z=lambda props: props.getProperty('x') + props.getProperty('y')
)
res = yield self.build.render(command)
self.assertEqual(res, '30')
@defer.inlineCallbacks
def testColon(self):
self.props.setProperty('some:property', 10, 'test')
command = WithProperties('%(some:property:-with-default)s')
res = yield self.build.render(command)
self.assertEqual(res, '10')
@defer.inlineCallbacks
def testColon_default(self):
command = WithProperties('%(some:property:-with-default)s')
res = yield self.build.render(command)
self.assertEqual(res, 'with-default')
@defer.inlineCallbacks
def testColon_colon(self):
command = WithProperties('%(some:property:-with:default)s')
res = yield self.build.render(command)
self.assertEqual(res, 'with:default')
class TestProperties(unittest.TestCase):
def setUp(self):
self.props = Properties()
def testDictBehavior(self):
# note that dictionary-like behavior is deprecated and not exposed to
# users!
self.props.setProperty("do-tests", 1, "scheduler")
self.props.setProperty("do-install", 2, "scheduler")
self.assertTrue('do-tests' in self.props)
self.assertEqual(self.props['do-tests'], 1)
self.assertEqual(self.props['do-install'], 2)
with self.assertRaises(KeyError):
self.props['do-nothing']
self.assertEqual(self.props.getProperty('do-install'), 2)
self.assertIn('do-tests', self.props)
self.assertNotIn('missing-do-tests', self.props)
def testAsList(self):
self.props.setProperty("happiness", 7, "builder")
self.props.setProperty("flames", True, "tester")
self.assertEqual(
sorted(self.props.asList()), [('flames', True, 'tester'), ('happiness', 7, 'builder')]
)
def testAsDict(self):
self.props.setProperty("msi_filename", "product.msi", 'packager')
self.props.setProperty("dmg_filename", "product.dmg", 'packager')
self.assertEqual(
self.props.asDict(),
{
"msi_filename": ('product.msi', 'packager'),
"dmg_filename": ('product.dmg', 'packager'),
},
)
def testUpdate(self):
self.props.setProperty("x", 24, "old")
newprops = {'a': 1, 'b': 2}
self.props.update(newprops, "new")
self.assertEqual(self.props.getProperty('x'), 24)
self.assertEqual(self.props.getPropertySource('x'), 'old')
self.assertEqual(self.props.getProperty('a'), 1)
self.assertEqual(self.props.getPropertySource('a'), 'new')
def testUpdateRuntime(self):
self.props.setProperty("x", 24, "old")
newprops = {'a': 1, 'b': 2}
self.props.update(newprops, "new", runtime=True)
self.assertEqual(self.props.getProperty('x'), 24)
self.assertEqual(self.props.getPropertySource('x'), 'old')
self.assertEqual(self.props.getProperty('a'), 1)
self.assertEqual(self.props.getPropertySource('a'), 'new')
self.assertEqual(self.props.runtime, set(['a', 'b']))
def testUpdateFromProperties(self):
self.props.setProperty("a", 94, "old")
self.props.setProperty("x", 24, "old")
newprops = Properties()
newprops.setProperty('a', 1, "new")
newprops.setProperty('b', 2, "new")
self.props.updateFromProperties(newprops)
self.assertEqual(self.props.getProperty('x'), 24)
self.assertEqual(self.props.getPropertySource('x'), 'old')
self.assertEqual(self.props.getProperty('a'), 1)
self.assertEqual(self.props.getPropertySource('a'), 'new')
def testUpdateFromPropertiesNoRuntime(self):
self.props.setProperty("a", 94, "old")
self.props.setProperty("b", 84, "old")
self.props.setProperty("x", 24, "old")
newprops = Properties()
newprops.setProperty('a', 1, "new", runtime=True)
newprops.setProperty('b', 2, "new", runtime=False)
newprops.setProperty('c', 3, "new", runtime=True)
newprops.setProperty('d', 3, "new", runtime=False)
self.props.updateFromPropertiesNoRuntime(newprops)
self.assertEqual(self.props.getProperty('a'), 94)
self.assertEqual(self.props.getPropertySource('a'), 'old')
self.assertEqual(self.props.getProperty('b'), 2)
self.assertEqual(self.props.getPropertySource('b'), 'new')
self.assertEqual(self.props.getProperty('c'), None) # not updated
self.assertEqual(self.props.getProperty('d'), 3)
self.assertEqual(self.props.getPropertySource('d'), 'new')
self.assertEqual(self.props.getProperty('x'), 24)
self.assertEqual(self.props.getPropertySource('x'), 'old')
def test_setProperty_notJsonable(self):
with self.assertRaises(TypeError):
self.props.setProperty("project", object, "test")
# IProperties methods
def test_getProperty(self):
self.props.properties['p1'] = (['p', 1], 'test')
self.assertEqual(self.props.getProperty('p1'), ['p', 1])
def test_getProperty_default_None(self):
self.assertEqual(self.props.getProperty('p1'), None)
def test_getProperty_default(self):
self.assertEqual(self.props.getProperty('p1', 2), 2)
def test_hasProperty_false(self):
self.assertFalse(self.props.hasProperty('x'))
def test_hasProperty_true(self):
self.props.properties['x'] = (False, 'test')
self.assertTrue(self.props.hasProperty('x'))
def test_has_key_false(self):
self.assertFalse('x' in self.props)
def test_setProperty(self):
self.props.setProperty('x', 'y', 'test')
self.assertEqual(self.props.properties['x'], ('y', 'test'))
self.assertNotIn('x', self.props.runtime)
def test_setProperty_runtime(self):
self.props.setProperty('x', 'y', 'test', runtime=True)
self.assertEqual(self.props.properties['x'], ('y', 'test'))
self.assertIn('x', self.props.runtime)
def test_setProperty_no_source(self):
# pylint: disable=no-value-for-parameter
with self.assertRaises(TypeError):
self.props.setProperty('x', 'y')
def test_getProperties(self):
self.assertIdentical(self.props.getProperties(), self.props)
def test_getBuild(self):
self.assertIdentical(self.props.getBuild(), self.props.build)
def test_unset_sourcestamps(self):
with self.assertRaises(AttributeError):
self.props.sourcestamps()
def test_unset_changes(self):
with self.assertRaises(AttributeError):
self.props.changes()
with self.assertRaises(AttributeError):
self.props.files()
def test_build_attributes(self):
build = FakeBuild(self.props)
change = TempChange({'author': 'me', 'files': ['main.c']})
ss = TempSourceStamp({'branch': 'master'})
ss.changes = [change]
build.sources[''] = ss
self.assertEqual(self.props.sourcestamps[0]['branch'], 'master')
self.assertEqual(self.props.changes[0]['author'], 'me')
self.assertEqual(self.props.files[0], 'main.c')
def test_own_attributes(self):
self.props.sourcestamps = [{'branch': 'master'}]
self.props.changes = [{'author': 'me', 'files': ['main.c']}]
self.assertEqual(self.props.sourcestamps[0]['branch'], 'master')
self.assertEqual(self.props.changes[0]['author'], 'me')
self.assertEqual(self.props.files[0], 'main.c')
@defer.inlineCallbacks
def test_render(self):
@implementer(IRenderable)
class Renderable:
def getRenderingFor(self, props):
return props.getProperty('x') + 'z'
self.props.setProperty('x', 'y', 'test')
res = yield self.props.render(Renderable())
self.assertEqual(res, 'yz')
class MyPropertiesThing(PropertiesMixin):
set_runtime_properties = True
def getProperties(self):
return self.properties
class TestPropertiesMixin(unittest.TestCase):
def setUp(self):
self.mp = MyPropertiesThing()
self.mp.properties = mock.Mock()
def test_getProperty(self):
self.mp.getProperty('abc')
self.mp.properties.getProperty.assert_called_with('abc', None)
def xtest_getProperty_default(self):
self.mp.getProperty('abc', 'def')
self.mp.properties.getProperty.assert_called_with('abc', 'def')
def test_hasProperty(self):
self.mp.properties.hasProperty.return_value = True
self.assertTrue(self.mp.hasProperty('abc'))
self.mp.properties.hasProperty.assert_called_with('abc')
def test_has_key(self):
self.mp.properties.hasProperty.return_value = True
# getattr because pep8 doesn't like calls to has_key
self.assertTrue(self.mp.has_key('abc'))
self.mp.properties.hasProperty.assert_called_with('abc')
def test_setProperty(self):
self.mp.setProperty('abc', 'def', 'src')
self.mp.properties.setProperty.assert_called_with('abc', 'def', 'src', runtime=True)
def test_setProperty_no_source(self):
# this compatibility is maintained for old code
self.mp.setProperty('abc', 'def')
self.mp.properties.setProperty.assert_called_with('abc', 'def', 'Unknown', runtime=True)
def test_render(self):
self.mp.render([1, 2])
self.mp.properties.render.assert_called_with([1, 2])
class TestProperty(unittest.TestCase):
def setUp(self):
self.props = Properties()
self.build = FakeBuild(props=self.props)
@defer.inlineCallbacks
def testIntProperty(self):
self.props.setProperty("do-tests", 1, "scheduler")
value = Property("do-tests")
res = yield self.build.render(value)
self.assertEqual(res, 1)
@defer.inlineCallbacks
def testStringProperty(self):
self.props.setProperty("do-tests", "string", "scheduler")
value = Property("do-tests")
res = yield self.build.render(value)
self.assertEqual(res, "string")
@defer.inlineCallbacks
def testMissingProperty(self):
value = Property("do-tests")
res = yield self.build.render(value)
self.assertEqual(res, None)
@defer.inlineCallbacks
def testDefaultValue(self):
value = Property("do-tests", default="Hello!")
res = yield self.build.render(value)
self.assertEqual(res, "Hello!")
@defer.inlineCallbacks
def testDefaultValueNested(self):
self.props.setProperty("xxx", 'yyy', "scheduler")
value = Property("do-tests", default=WithProperties("a-%(xxx)s-b"))
res = yield self.build.render(value)
self.assertEqual(res, "a-yyy-b")
@defer.inlineCallbacks
def testIgnoreDefaultValue(self):
self.props.setProperty("do-tests", "string", "scheduler")
value = Property("do-tests", default="Hello!")
res = yield self.build.render(value)
self.assertEqual(res, "string")
@defer.inlineCallbacks
def testIgnoreFalseValue(self):
self.props.setProperty("do-tests-string", "", "scheduler")
self.props.setProperty("do-tests-int", 0, "scheduler")
self.props.setProperty("do-tests-list", [], "scheduler")
self.props.setProperty("do-tests-None", None, "scheduler")
value = [
Property("do-tests-string", default="Hello!"),
Property("do-tests-int", default="Hello!"),
Property("do-tests-list", default="Hello!"),
Property("do-tests-None", default="Hello!"),
]
res = yield self.build.render(value)
self.assertEqual(res, ["Hello!"] * 4)
@defer.inlineCallbacks
def testDefaultWhenFalse(self):
self.props.setProperty("do-tests-string", "", "scheduler")
self.props.setProperty("do-tests-int", 0, "scheduler")
self.props.setProperty("do-tests-list", [], "scheduler")
self.props.setProperty("do-tests-None", None, "scheduler")
value = [
Property("do-tests-string", default="Hello!", defaultWhenFalse=False),
Property("do-tests-int", default="Hello!", defaultWhenFalse=False),
Property("do-tests-list", default="Hello!", defaultWhenFalse=False),
Property("do-tests-None", default="Hello!", defaultWhenFalse=False),
]
res = yield self.build.render(value)
self.assertEqual(res, ["", 0, [], None])
def testDeferredDefault(self):
default = DeferredRenderable()
value = Property("no-such-property", default)
d = self.build.render(value)
d.addCallback(self.assertEqual, "default-value")
default.callback("default-value")
return d
@defer.inlineCallbacks
def testFlattenList(self):
self.props.setProperty("do-tests", "string", "scheduler")
value = FlattenList([Property("do-tests"), ["bla"]])
res = yield self.build.render(value)
self.assertEqual(res, ["string", "bla"])
@defer.inlineCallbacks
def testFlattenListAdd(self):
self.props.setProperty("do-tests", "string", "scheduler")
value = FlattenList([Property("do-tests"), ["bla"]])
value = value + FlattenList([Property("do-tests"), ["bla"]])
res = yield self.build.render(value)
self.assertEqual(res, ["string", "bla", "string", "bla"])
@defer.inlineCallbacks
def testFlattenListAdd2(self):
self.props.setProperty("do-tests", "string", "scheduler")
value = FlattenList([Property("do-tests"), ["bla"]])
value = value + [Property('do-tests'), ['bla']] # noqa: RUF005
res = yield self.build.render(value)
self.assertEqual(res, ["string", "bla", "string", "bla"])
@defer.inlineCallbacks
def testCompEq(self):
self.props.setProperty("do-tests", "string", "scheduler")
result = yield self.build.render(Property("do-tests") == "string")
self.assertEqual(result, True)
@defer.inlineCallbacks
def testCompNe(self):
self.props.setProperty("do-tests", "not-string", "scheduler")
result = yield self.build.render(Property("do-tests") != "string")
self.assertEqual(result, True)
@defer.inlineCallbacks
def testCompLt(self):
self.props.setProperty("do-tests", 1, "scheduler")
x = Property("do-tests") < 2
self.assertEqual(repr(x), 'Property(do-tests) < 2')
result = yield self.build.render(x)
self.assertEqual(result, True)
@defer.inlineCallbacks
def testCompLe(self):
self.props.setProperty("do-tests", 1, "scheduler")
result = yield self.build.render(Property("do-tests") <= 2)
self.assertEqual(result, True)
@defer.inlineCallbacks
def testCompGt(self):
self.props.setProperty("do-tests", 3, "scheduler")
result = yield self.build.render(Property("do-tests") > 2)
self.assertEqual(result, True)
@defer.inlineCallbacks
def testCompGe(self):
self.props.setProperty("do-tests", 3, "scheduler")
result = yield self.build.render(Property("do-tests") >= 2)
self.assertEqual(result, True)
@defer.inlineCallbacks
def testStringCompEq(self):
self.props.setProperty("do-tests", "string", "scheduler")
test_string = "string"
result = yield self.build.render(test_string == Property("do-tests"))
self.assertEqual(result, True)
@defer.inlineCallbacks
def testIntCompLe(self):
self.props.setProperty("do-tests", 1, "scheduler")
test_int = 1
result = yield self.build.render(test_int <= Property("do-tests"))
self.assertEqual(result, True)
@defer.inlineCallbacks
def testPropCompGe(self):
self.props.setProperty("do-tests", 1, "scheduler")
result = yield self.build.render(Property("do-tests") >= Property("do-tests"))
self.assertEqual(result, True)
@defer.inlineCallbacks
def testPropAdd(self):
self.props.setProperty("do-tests", 1, "scheduler")
result = yield self.build.render(Property("do-tests") + Property("do-tests"))
self.assertEqual(result, 2)
@defer.inlineCallbacks
def testPropSub(self):
self.props.setProperty("do-tests", 1, "scheduler")
result = yield self.build.render(Property("do-tests") - Property("do-tests"))
self.assertEqual(result, 0)
@defer.inlineCallbacks
def testPropDiv(self):
self.props.setProperty("do-tests", 1, "scheduler")
self.props.setProperty("do-tests2", 3, "scheduler")
result = yield self.build.render(Property("do-tests") / Property("do-tests2"))
self.assertEqual(result, 1 / 3)
@defer.inlineCallbacks
def testPropFDiv(self):
self.props.setProperty("do-tests", 5, "scheduler")
self.props.setProperty("do-tests2", 2, "scheduler")
result = yield self.build.render(Property("do-tests") // Property("do-tests2"))
self.assertEqual(result, 2)
@defer.inlineCallbacks
def testPropMod(self):
self.props.setProperty("do-tests", 5, "scheduler")
self.props.setProperty("do-tests2", 3, "scheduler")
result = yield self.build.render(Property("do-tests") % Property("do-tests2"))
self.assertEqual(result, 2)
@defer.inlineCallbacks
def testPropMult(self):
self.props.setProperty("do-tests", 2, "scheduler")
result = yield self.build.render(Property("do-tests") * Interpolate("%(prop:do-tests)s"))
self.assertEqual(result, '22')
@defer.inlineCallbacks
def testPropIn(self):
self.props.setProperty("do-tests", 2, "scheduler")
result = yield self.build.render(Property("do-tests").in_([1, 2]))
self.assertEqual(result, True)
@defer.inlineCallbacks
def testPropIn2(self):
self.props.setProperty("do-tests", 2, "scheduler")
result = yield self.build.render(Property("do-tests").in_([1, 3]))
self.assertEqual(result, False)
class TestRenderableAdapters(unittest.TestCase):
"""
Tests for list, tuple and dict renderers.
"""
def setUp(self):
self.props = Properties()
self.build = FakeBuild(props=self.props)
def test_list_deferred(self):
r1 = DeferredRenderable()
r2 = DeferredRenderable()
d = self.build.render([r1, r2])
d.addCallback(self.assertEqual, ["lispy", "lists"])
r2.callback("lists")
r1.callback("lispy")
return d
def test_tuple_deferred(self):
r1 = DeferredRenderable()
r2 = DeferredRenderable()
d = self.build.render((r1, r2))
d.addCallback(self.assertEqual, ("totally", "tupled"))
r2.callback("tupled")
r1.callback("totally")
return d
def test_dict(self):
r1 = DeferredRenderable()
r2 = DeferredRenderable()
k1 = DeferredRenderable()
k2 = DeferredRenderable()
d = self.build.render({k1: r1, k2: r2})
d.addCallback(self.assertEqual, {"lock": "load", "dict": "lookup"})
k1.callback("lock")
r1.callback("load")
k2.callback("dict")
r2.callback("lookup")
return d
class Renderer(unittest.TestCase):
def setUp(self):
self.props = Properties()
self.build = FakeBuild(props=self.props)
@defer.inlineCallbacks
def test_renderer(self):
self.props.setProperty("x", "X", "test")
def rend(p):
return f"x{p.getProperty('x')}x"
res = yield self.build.render(renderer(rend))
self.assertEqual('xXx', res)
@defer.inlineCallbacks
def test_renderer_called(self):
# it's tempting to try to call the decorated function. Don't do that.
# It's not a function anymore.
def rend(p):
return 'x'
with self.assertRaises(TypeError):
yield self.build.render(renderer(rend)('y'))
@defer.inlineCallbacks
def test_renderer_decorator(self):
self.props.setProperty("x", "X", "test")
@renderer
def rend(p):
return f"x{p.getProperty('x')}x"
res = yield self.build.render(rend)
self.assertEqual('xXx', res)
@defer.inlineCallbacks
def test_renderer_deferred(self):
self.props.setProperty("x", "X", "test")
def rend(p):
return defer.succeed(f"y{p.getProperty('x')}y")
res = yield self.build.render(renderer(rend))
self.assertEqual('yXy', res)
@defer.inlineCallbacks
def test_renderer_fails(self):
@defer.inlineCallbacks
def rend(p):
raise RuntimeError("oops")
with self.assertRaises(RuntimeError):
yield self.build.render(renderer(rend))
@defer.inlineCallbacks
def test_renderer_recursive(self):
self.props.setProperty("x", "X", "test")
def rend(p):
return Interpolate("x%(prop:x)sx")
ret = yield self.build.render(renderer(rend))
self.assertEqual('xXx', ret)
def test_renderer_repr(self):
@renderer
def myrend(p):
pass
self.assertIn('renderer(', repr(myrend))
# py3 and py2 do not have the same way of repr functions
# but they always contain the name of function
self.assertIn('myrend', repr(myrend))
@defer.inlineCallbacks
def test_renderer_with_state(self):
self.props.setProperty("x", "X", "test")
def rend(p, arg, kwarg='y'):
return f"x-{p.getProperty('x')}-{arg}-{kwarg}"
res = yield self.build.render(renderer(rend).withArgs('a', kwarg='kw'))
self.assertEqual('x-X-a-kw', res)
@defer.inlineCallbacks
def test_renderer_with_state_called(self):
# it's tempting to try to call the decorated function. Don't do that.
# It's not a function anymore.
def rend(p, arg, kwarg='y'):
return 'x'
with self.assertRaises(TypeError):
rend_with_args = renderer(rend).withArgs('a', kwarg='kw')
yield self.build.render(rend_with_args('y'))
@defer.inlineCallbacks
def test_renderer_with_state_renders_args(self):
self.props.setProperty("x", "X", "test")
self.props.setProperty('arg', 'ARG', 'test2')
self.props.setProperty('kw', 'KW', 'test3')
def rend(p, arg, kwarg='y'):
return f"x-{p.getProperty('x')}-{arg}-{kwarg}"
res = yield self.build.render(
renderer(rend).withArgs(Property('arg'), kwarg=Property('kw'))
)
self.assertEqual('x-X-ARG-KW', res)
@defer.inlineCallbacks
def test_renderer_decorator_with_state(self):
self.props.setProperty("x", "X", "test")
@renderer
def rend(p, arg, kwarg='y'):
return f"x-{p.getProperty('x')}-{arg}-{kwarg}"
res = yield self.build.render(rend.withArgs('a', kwarg='kw'))
self.assertEqual('x-X-a-kw', res)
@defer.inlineCallbacks
def test_renderer_decorator_with_state_does_not_share_state(self):
self.props.setProperty("x", "X", "test")
@renderer
def rend(p, *args, **kwargs):
return f"x-{p.getProperty('x')}-{args!s}-{kwargs!s}"
rend1 = rend.withArgs('a', kwarg1='kw1')
rend2 = rend.withArgs('b', kwarg2='kw2')
res1 = yield self.build.render(rend1)
res2 = yield self.build.render(rend2)
self.assertEqual('x-X-(\'a\',)-{\'kwarg1\': \'kw1\'}', res1)
self.assertEqual('x-X-(\'b\',)-{\'kwarg2\': \'kw2\'}', res2)
@defer.inlineCallbacks
def test_renderer_deferred_with_state(self):
self.props.setProperty("x", "X", "test")
def rend(p, arg, kwarg='y'):
return defer.succeed(f"x-{p.getProperty('x')}-{arg}-{kwarg}")
res = yield self.build.render(renderer(rend).withArgs('a', kwarg='kw'))
self.assertEqual('x-X-a-kw', res)
@defer.inlineCallbacks
def test_renderer_fails_with_state(self):
self.props.setProperty("x", "X", "test")
def rend(p, arg, kwarg='y'):
raise RuntimeError('oops')
with self.assertRaises(RuntimeError):
yield self.build.render(renderer(rend).withArgs('a', kwarg='kw'))
@defer.inlineCallbacks
def test_renderer_recursive_with_state(self):
self.props.setProperty("x", "X", "test")
def rend(p, arg, kwarg='y'):
return Interpolate('x-%(prop:x)s-%(kw:arg)s-%(kw:kwarg)s', arg=arg, kwarg=kwarg)
res = yield self.build.render(renderer(rend).withArgs('a', kwarg='kw'))
self.assertEqual('x-X-a-kw', res)
def test_renderer_repr_with_state(self):
@renderer
def rend(p):
pass
rend = rend.withArgs('a', kwarg='kw') # pylint: disable=assignment-from-no-return
self.assertIn('renderer(', repr(rend))
# py3 and py2 do not have the same way of repr functions
# but they always contain the name of function
self.assertIn('args=[\'a\']', repr(rend))
self.assertIn('kwargs={\'kwarg\': \'kw\'}', repr(rend))
@defer.inlineCallbacks
def test_interpolate_worker(self):
self.build.workerforbuilder.worker.info.setProperty('test', 'testvalue', 'Worker')
rend = yield self.build.render(Interpolate("%(worker:test)s"))
self.assertEqual(rend, "testvalue")
class Compare(unittest.TestCase):
def test_WithProperties_lambda(self):
self.assertNotEqual(
WithProperties("%(key)s", key=lambda p: 'val'),
WithProperties("%(key)s", key=lambda p: 'val'),
)
def rend(p):
return "val"
self.assertEqual(WithProperties("%(key)s", key=rend), WithProperties("%(key)s", key=rend))
self.assertNotEqual(
WithProperties("%(key)s", key=rend), WithProperties("%(key)s", otherkey=rend)
)
def test_WithProperties_positional(self):
self.assertNotEqual(WithProperties("%s", 'key'), WithProperties("%s", 'otherkey'))
self.assertEqual(WithProperties("%s", 'key'), WithProperties("%s", 'key'))
self.assertNotEqual(WithProperties("%s", 'key'), WithProperties("k%s", 'key'))
def test_Interpolate_constant(self):
self.assertNotEqual(Interpolate('some text here'), Interpolate('and other text there'))
self.assertEqual(Interpolate('some text here'), Interpolate('some text here'))
def test_Interpolate_positional(self):
self.assertNotEqual(
Interpolate('%s %s', "test", "text"), Interpolate('%s %s', "other", "text")
)
self.assertEqual(Interpolate('%s %s', "test", "text"), Interpolate('%s %s', "test", "text"))
def test_Interpolate_kwarg(self):
self.assertNotEqual(
Interpolate("%(kw:test)s", test=object(), other=2),
Interpolate("%(kw:test)s", test=object(), other=2),
)
self.assertEqual(
Interpolate('testing: %(kw:test)s', test="test", other=3),
Interpolate('testing: %(kw:test)s', test="test", other=3),
)
def test_Interpolate_worker(self):
self.assertEqual(
Interpolate('testing: %(worker:test)s'), Interpolate('testing: %(worker:test)s')
)
def test_renderer(self):
self.assertNotEqual(renderer(lambda p: 'val'), renderer(lambda p: 'val'))
def rend(p):
return "val"
self.assertEqual(renderer(rend), renderer(rend))
def test_Lookup_simple(self):
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'other'), _Lookup({'test': 5, 'other': 6}, 'test')
)
self.assertEqual(
_Lookup({'test': 5, 'other': 6}, 'test'), _Lookup({'test': 5, 'other': 6}, 'test')
)
def test_Lookup_default(self):
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'test', default='default'),
_Lookup({'test': 5, 'other': 6}, 'test'),
)
self.assertEqual(
_Lookup({'test': 5, 'other': 6}, 'test', default='default'),
_Lookup({'test': 5, 'other': 6}, 'test', default='default'),
)
def test_Lookup_defaultWhenFalse(self):
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'test', defaultWhenFalse=False),
_Lookup({'test': 5, 'other': 6}, 'test'),
)
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'test', defaultWhenFalse=False),
_Lookup({'test': 5, 'other': 6}, 'test', defaultWhenFalse=True),
)
self.assertEqual(
_Lookup({'test': 5, 'other': 6}, 'test', defaultWhenFalse=True),
_Lookup({'test': 5, 'other': 6}, 'test', defaultWhenFalse=True),
)
self.assertEqual(
_Lookup({'test': 5, 'other': 6}, 'test'),
_Lookup({'test': 5, 'other': 6}, 'test', defaultWhenFalse=True),
)
def test_Lookup_hasKey(self):
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'test', hasKey=None),
_Lookup({'test': 5, 'other': 6}, 'test'),
)
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'test', hasKey='has-key'),
_Lookup({'test': 5, 'other': 6}, 'test'),
)
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'test', hasKey='has-key'),
_Lookup({'test': 5, 'other': 6}, 'test', hasKey='other-key'),
)
self.assertEqual(
_Lookup({'test': 5, 'other': 6}, 'test', hasKey='has-key'),
_Lookup({'test': 5, 'other': 6}, 'test', hasKey='has-key'),
)
def test_Lookup_elideNoneAs(self):
self.assertEqual(
_Lookup({'test': 5, 'other': 6}, 'test', elideNoneAs=None),
_Lookup({'test': 5, 'other': 6}, 'test'),
)
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'test', elideNoneAs=''),
_Lookup({'test': 5, 'other': 6}, 'test'),
)
self.assertNotEqual(
_Lookup({'test': 5, 'other': 6}, 'test', elideNoneAs='got None'),
_Lookup({'test': 5, 'other': 6}, 'test', elideNoneAs=''),
)
self.assertEqual(
_Lookup({'test': 5, 'other': 6}, 'test', elideNoneAs='got None'),
_Lookup({'test': 5, 'other': 6}, 'test', elideNoneAs='got None'),
)
def test_Lazy(self):
self.assertNotEqual(_Lazy(5), _Lazy(6))
self.assertEqual(_Lazy(5), _Lazy(5))
def test_SourceStampDict(self):
self.assertNotEqual(_SourceStampDict('binary'), _SourceStampDict('library'))
self.assertEqual(_SourceStampDict('binary'), _SourceStampDict('binary'))
class TestTransform(unittest.TestCase, ConfigErrorsMixin):
def setUp(self):
self.props = Properties(propname='propvalue')
def test_invalid_first_arg(self):
with self.assertRaisesConfigError(
"function given to Transform neither callable nor renderable"
):
Transform(None)
@defer.inlineCallbacks
def test_argless(self):
t = Transform(lambda: 'abc')
res = yield self.props.render(t)
self.assertEqual(res, 'abc')
@defer.inlineCallbacks
def test_argless_renderable(self):
@renderer
def function(iprops):
return lambda: iprops.getProperty('propname')
t = Transform(function)
res = yield self.props.render(t)
self.assertEqual(res, 'propvalue')
@defer.inlineCallbacks
def test_args(self):
t = Transform(lambda x, y: x + '|' + y, 'abc', Property('propname'))
res = yield self.props.render(t)
self.assertEqual(res, 'abc|propvalue')
@defer.inlineCallbacks
def test_kwargs(self):
t = Transform(lambda x, y: x + '|' + y, x='abc', y=Property('propname'))
res = yield self.props.render(t)
self.assertEqual(res, 'abc|propvalue')
def test_deferred(self):
function = DeferredRenderable()
arg = DeferredRenderable()
kwarg = DeferredRenderable()
t = Transform(function, arg, y=kwarg)
d = self.props.render(t)
d.addCallback(self.assertEqual, 'abc|def')
function.callback(lambda x, y: x + '|' + y)
arg.callback('abc')
kwarg.callback('def')
return d
| 65,825 | Python | .py | 1,414 | 38.272277 | 100 | 0.646428 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,450 | test_logobserver.py | buildbot_buildbot/master/buildbot/test/unit/process/test_logobserver.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process import log
from buildbot.process import logobserver
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
class MyLogObserver(logobserver.LogObserver):
def __init__(self):
self.obs = []
def outReceived(self, data):
self.obs.append(('out', data))
def errReceived(self, data):
self.obs.append(('err', data))
def headerReceived(self, data):
self.obs.append(('hdr', data))
def finishReceived(self):
self.obs.append(('fin',))
class TestLogObserver(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_sequence(self):
logid = yield self.master.data.updates.addLog(1, 'mine', 's')
_log = log.Log.new(self.master, 'mine', 's', logid, 'utf-8')
lo = MyLogObserver()
lo.setLog(_log)
yield _log.addStdout('hello\n')
yield _log.addStderr('cruel\n')
yield _log.addStdout('world\n')
yield _log.addStdout('multi\nline\nchunk\n')
yield _log.addHeader('HDR\n')
yield _log.finish()
self.assertEqual(
lo.obs,
[
('out', 'hello\n'),
('err', 'cruel\n'),
('out', 'world\n'),
('out', 'multi\nline\nchunk\n'),
('hdr', 'HDR\n'),
('fin',),
],
)
class MyLogLineObserver(logobserver.LogLineObserver):
def __init__(self):
super().__init__()
self.obs = []
def outLineReceived(self, line):
self.obs.append(('out', line))
def errLineReceived(self, line):
self.obs.append(('err', line))
def headerLineReceived(self, line):
self.obs.append(('hdr', line))
def finishReceived(self):
self.obs.append(('fin',))
class TestLineConsumerLogObesrver(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def do_test_sequence(self, consumer):
logid = yield self.master.data.updates.addLog(1, 'mine', 's')
_log = log.Log.new(self.master, 'mine', 's', logid, 'utf-8')
lo = logobserver.LineConsumerLogObserver(consumer)
lo.setLog(_log)
yield _log.addStdout('hello\n')
yield _log.addStderr('cruel\n')
yield _log.addStdout('multi\nline\nchunk\n')
yield _log.addHeader('H1\nH2\n')
yield _log.finish()
@defer.inlineCallbacks
def test_sequence_finish(self):
results = []
def consumer():
while True:
try:
stream, line = yield
results.append((stream, line))
except GeneratorExit:
results.append('finish')
raise
yield self.do_test_sequence(consumer)
self.assertEqual(
results,
[
('o', 'hello'),
('e', 'cruel'),
('o', 'multi'),
('o', 'line'),
('o', 'chunk'),
('h', 'H1'),
('h', 'H2'),
'finish',
],
)
@defer.inlineCallbacks
def test_sequence_no_finish(self):
results = []
def consumer():
while True:
stream, line = yield
results.append((stream, line))
yield self.do_test_sequence(consumer)
self.assertEqual(
results,
[
('o', 'hello'),
('e', 'cruel'),
('o', 'multi'),
('o', 'line'),
('o', 'chunk'),
('h', 'H1'),
('h', 'H2'),
],
)
class TestLogLineObserver(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_sequence(self):
logid = yield self.master.data.updates.addLog(1, 'mine', 's')
_log = log.Log.new(self.master, 'mine', 's', logid, 'utf-8')
lo = MyLogLineObserver()
lo.setLog(_log)
yield _log.addStdout('hello\n')
yield _log.addStderr('cruel\n')
yield _log.addStdout('multi\nline\nchunk\n')
yield _log.addHeader('H1\nH2\n')
yield _log.finish()
self.assertEqual(
lo.obs,
[
('out', 'hello'),
('err', 'cruel'),
('out', 'multi'),
('out', 'line'),
('out', 'chunk'),
('hdr', 'H1'),
('hdr', 'H2'),
('fin',),
],
)
def test_old_setMaxLineLength(self):
# this method is gone, but used to be documented, so it's still
# callable. Just don't fail.
lo = MyLogLineObserver()
lo.setMaxLineLength(120939403)
class TestOutputProgressObserver(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_sequence(self):
logid = yield self.master.data.updates.addLog(1, 'mine', 's')
_log = log.Log.new(self.master, 'mine', 's', logid, 'utf-8')
lo = logobserver.OutputProgressObserver('stdio')
step = mock.Mock()
lo.setStep(step)
lo.setLog(_log)
yield _log.addStdout('hello\n')
step.setProgress.assert_called_with('stdio', 6)
yield _log.finish()
class TestBufferObserver(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def do_test_sequence(self, lo):
logid = yield self.master.data.updates.addLog(1, 'mine', 's')
_log = log.Log.new(self.master, 'mine', 's', logid, 'utf-8')
lo.setLog(_log)
yield _log.addStdout('hello\n')
yield _log.addStderr('cruel\n')
yield _log.addStdout('multi\nline\nchunk\n')
yield _log.addHeader('H1\nH2\n')
yield _log.finish()
@defer.inlineCallbacks
def test_stdout_only(self):
lo = logobserver.BufferLogObserver(wantStdout=True, wantStderr=False)
yield self.do_test_sequence(lo)
self.assertEqual(lo.getStdout(), 'hello\nmulti\nline\nchunk\n')
self.assertEqual(lo.getStderr(), '')
@defer.inlineCallbacks
def test_both(self):
lo = logobserver.BufferLogObserver(wantStdout=True, wantStderr=True)
yield self.do_test_sequence(lo)
self.assertEqual(lo.getStdout(), 'hello\nmulti\nline\nchunk\n')
self.assertEqual(lo.getStderr(), 'cruel\n')
| 8,559 | Python | .py | 225 | 29.031111 | 79 | 0.599034 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,451 | test_users_manual.py | buildbot_buildbot/master/buildbot/test/unit/process/test_users_manual.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
# this class is known to contain cruft and will be looked at later, so
# no current implementation utilizes it aside from scripts.runner.
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.db.users import UserModel
from buildbot.process.users import manual
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
class ManualUsersMixin:
"""
This class fakes out the master/db components to test the manual
user managers located in process.users.manual.
"""
@defer.inlineCallbacks
def setUpManualUsers(self):
self.master = yield fakemaster.make_master(self, wantDb=True)
class TestUsersBase(unittest.TestCase):
"""
Not really sure what there is to test, aside from _setUpManualUsers getting
self.master set.
"""
class TestCommandlineUserManagerPerspective(TestReactorMixin, unittest.TestCase, ManualUsersMixin):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setUpManualUsers()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def call_perspective_commandline(self, *args):
persp = manual.CommandlineUserManagerPerspective(self.master)
return persp.perspective_commandline(*args)
@defer.inlineCallbacks
def test_perspective_commandline_add(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x', 'git': 'x'}]
)
usdict = yield self.master.db.users.getUser(1)
self.assertEqual(
usdict,
UserModel(
uid=1, identifier='x', bb_username=None, bb_password=None, attributes={"git": 'x'}
),
)
@defer.inlineCallbacks
def test_perspective_commandline_update(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x', 'svn': 'x'}]
)
yield self.call_perspective_commandline(
'update', None, None, None, [{'identifier': 'x', 'svn': 'y'}]
)
usdict = yield self.master.db.users.getUser(1)
self.assertEqual(
usdict,
UserModel(
uid=1, identifier='x', bb_username=None, bb_password=None, attributes={"svn": 'y'}
),
)
@defer.inlineCallbacks
def test_perspective_commandline_update_bb(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x', 'svn': 'x'}]
)
yield self.call_perspective_commandline(
'update', 'bb_user', 'hashed_bb_pass', None, [{'identifier': 'x'}]
)
usdict = yield self.master.db.users.getUser(1)
self.assertEqual(
usdict,
UserModel(
uid=1,
identifier='x',
bb_username='bb_user',
bb_password='hashed_bb_pass',
attributes={"svn": 'x'},
),
)
@defer.inlineCallbacks
def test_perspective_commandline_update_both(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x', 'svn': 'x'}]
)
yield self.call_perspective_commandline(
'update', 'bb_user', 'hashed_bb_pass', None, [{'identifier': 'x', 'svn': 'y'}]
)
usdict = yield self.master.db.users.getUser(1)
self.assertEqual(
usdict,
UserModel(
uid=1,
identifier='x',
bb_username='bb_user',
bb_password='hashed_bb_pass',
attributes={"svn": 'y'},
),
)
@defer.inlineCallbacks
def test_perspective_commandline_remove(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'h@c', 'git': 'hi <h@c>'}]
)
yield self.call_perspective_commandline('remove', None, None, ['x'], None)
res = yield self.master.db.users.getUser('x')
self.assertEqual(res, None)
@defer.inlineCallbacks
def test_perspective_commandline_get(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x', 'svn': 'x'}]
)
yield self.call_perspective_commandline('get', None, None, ['x'], None)
res = yield self.master.db.users.getUser(1)
self.assertEqual(
res,
UserModel(
uid=1,
identifier='x',
bb_username=None,
bb_password=None,
attributes={"svn": 'x'},
),
)
@defer.inlineCallbacks
def test_perspective_commandline_get_multiple_attrs(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x', 'svn': 'x', 'git': 'x@c'}]
)
yield self.call_perspective_commandline('get', None, None, ['x'], None)
res = yield self.master.db.users.getUser(1)
self.assertEqual(
res,
UserModel(
uid=1,
identifier='x',
bb_username=None,
bb_password=None,
attributes={"svn": 'x', 'git': 'x@c'},
),
)
@defer.inlineCallbacks
def test_perspective_commandline_add_format(self):
result = yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x', 'svn': 'x'}]
)
exp_format = "user(s) added:\nidentifier: x\nuid: 1\n\n"
self.assertEqual(result, exp_format)
@defer.inlineCallbacks
def test_perspective_commandline_update_format(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x', 'svn': 'x'}]
)
result = yield self.call_perspective_commandline(
'update', None, None, None, [{'identifier': 'x', 'svn': 'y'}]
)
exp_format = 'user(s) updated:\nidentifier: x\n'
self.assertEqual(result, exp_format)
@defer.inlineCallbacks
def test_perspective_commandline_remove_format(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'h@c', 'git': 'hi <h@c>'}]
)
result = yield self.call_perspective_commandline('remove', None, None, ['h@c'], None)
exp_format = "user(s) removed:\nidentifier: h@c\n"
self.assertEqual(result, exp_format)
@defer.inlineCallbacks
def test_perspective_commandline_get_format(self):
yield self.call_perspective_commandline(
'add', None, None, None, [{'identifier': 'x@y', 'git': 'x <x@y>'}]
)
result = yield self.call_perspective_commandline('get', None, None, ['x@y'], None)
exp_format = (
'user(s) found:\n'
'uid: 1\n'
'identifier: x@y\n'
'bb_username: None\n'
'attributes:\n'
'\tgit: x <x@y>\n'
'\n'
)
self.assertEqual(result, exp_format)
@defer.inlineCallbacks
def test_perspective_commandline_remove_no_match_format(self):
result = yield self.call_perspective_commandline('remove', None, None, ['x'], None)
exp_format = "user(s) removed:\n"
self.assertEqual(result, exp_format)
@defer.inlineCallbacks
def test_perspective_commandline_get_no_match_format(self):
result = yield self.call_perspective_commandline('get', None, None, ['x'], None)
exp_format = "user(s) found:\nno match found\n"
self.assertEqual(result, exp_format)
class TestCommandlineUserManager(TestReactorMixin, unittest.TestCase, ManualUsersMixin):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setUpManualUsers()
self.manual_component = manual.CommandlineUserManager(
username="user", passwd="userpw", port="9990"
)
yield self.manual_component.setServiceParent(self.master)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def test_no_userpass(self):
d = defer.maybeDeferred(manual.CommandlineUserManager)
return self.assertFailure(d, AssertionError)
def test_no_port(self):
d = defer.maybeDeferred(manual.CommandlineUserManager, username="x", passwd="y")
return self.assertFailure(d, AssertionError)
@defer.inlineCallbacks
def test_service(self):
# patch out the pbmanager's 'register' command both to be sure
# the registration is correct and to get a copy of the factory
registration = mock.Mock()
registration.unregister = lambda: defer.succeed(None)
self.master.pbmanager = mock.Mock()
def register(portstr, user, passwd, factory):
self.assertEqual([portstr, user, passwd], ['9990', 'user', 'userpw'])
self.got_factory = factory
return defer.succeed(registration)
self.master.pbmanager.register = register
yield self.manual_component.startService()
persp = self.got_factory(mock.Mock(), 'user')
self.assertTrue(isinstance(persp, manual.CommandlineUserManagerPerspective))
yield self.manual_component.stopService()
| 10,154 | Python | .py | 238 | 33.672269 | 99 | 0.62462 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,452 | test_message.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_message.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import textwrap
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process.properties import Interpolate
from buildbot.process.results import CANCELLED
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SKIPPED
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.reporters import message
from buildbot.reporters import utils
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.misc import BuildDictLookAlike
class TestMessageFormatting(unittest.TestCase):
def test_get_detected_status_text_failure(self):
self.assertEqual(
message.get_detected_status_text(['change'], FAILURE, FAILURE), 'failed build'
)
self.assertEqual(
message.get_detected_status_text(['change'], FAILURE, SUCCESS), 'new failure'
)
self.assertEqual(
message.get_detected_status_text(['change'], FAILURE, None), 'failed build'
)
self.assertEqual(
message.get_detected_status_text(['problem'], FAILURE, FAILURE), 'failed build'
)
self.assertEqual(
message.get_detected_status_text(['problem'], FAILURE, SUCCESS), 'new failure'
)
self.assertEqual(
message.get_detected_status_text(['problem'], FAILURE, None), 'failed build'
)
def test_get_detected_status_text_warnings(self):
self.assertEqual(
message.get_detected_status_text(['change'], WARNINGS, SUCCESS), 'problem in the build'
)
self.assertEqual(
message.get_detected_status_text(['change'], WARNINGS, None), 'problem in the build'
)
def test_get_detected_status_text_success(self):
self.assertEqual(
message.get_detected_status_text(['change'], SUCCESS, FAILURE), 'restored build'
)
self.assertEqual(
message.get_detected_status_text(['change'], SUCCESS, SUCCESS), 'passing build'
)
self.assertEqual(
message.get_detected_status_text(['change'], SUCCESS, None), 'passing build'
)
self.assertEqual(
message.get_detected_status_text(['problem'], SUCCESS, FAILURE), 'passing build'
)
self.assertEqual(
message.get_detected_status_text(['problem'], SUCCESS, SUCCESS), 'passing build'
)
self.assertEqual(
message.get_detected_status_text(['problem'], SUCCESS, None), 'passing build'
)
def test_get_detected_status_text_exception(self):
self.assertEqual(
message.get_detected_status_text(['problem'], EXCEPTION, FAILURE), 'build exception'
)
self.assertEqual(
message.get_detected_status_text(['problem'], EXCEPTION, SUCCESS), 'build exception'
)
self.assertEqual(
message.get_detected_status_text(['problem'], EXCEPTION, None), 'build exception'
)
def test_get_detected_status_text_other(self):
self.assertEqual(
message.get_detected_status_text(['problem'], SKIPPED, None), 'skipped build'
)
self.assertEqual(message.get_detected_status_text(['problem'], RETRY, None), 'retry build')
self.assertEqual(
message.get_detected_status_text(['problem'], CANCELLED, None), 'cancelled build'
)
def test_get_message_summary_text_success(self):
self.assertEqual(
message.get_message_summary_text({'state_string': 'mywarning'}, SUCCESS),
'Build succeeded!',
)
def test_get_message_summary_text_warnings(self):
self.assertEqual(
message.get_message_summary_text({'state_string': 'mywarning'}, WARNINGS),
'Build Had Warnings: mywarning',
)
self.assertEqual(
message.get_message_summary_text({'state_string': None}, WARNINGS), 'Build Had Warnings'
)
def test_get_message_summary_text_cancelled(self):
self.assertEqual(
message.get_message_summary_text({'state_string': 'mywarning'}, CANCELLED),
'Build was cancelled',
)
def test_get_message_summary_text_skipped(self):
self.assertEqual(
message.get_message_summary_text({'state_string': 'mywarning'}, SKIPPED),
'BUILD FAILED: mywarning',
)
self.assertEqual(
message.get_message_summary_text({'state_string': None}, SKIPPED), 'BUILD FAILED'
)
def test_get_message_source_stamp_text_empty(self):
self.assertEqual(message.get_message_source_stamp_text([]), '')
def test_get_message_source_stamp_text_multiple(self):
stamps = [
{'codebase': 'a', 'branch': None, 'revision': None, 'patch': None},
{'codebase': 'b', 'branch': None, 'revision': None, 'patch': None},
]
self.assertEqual(
message.get_message_source_stamp_text(stamps),
"Build Source Stamp 'a': HEAD\nBuild Source Stamp 'b': HEAD\n",
)
def test_get_message_source_stamp_text_with_props(self):
stamps = [{'codebase': 'a', 'branch': 'br', 'revision': 'abc', 'patch': 'patch'}]
self.assertEqual(
message.get_message_source_stamp_text(stamps),
"Build Source Stamp 'a': [branch br] abc (plus patch)\n",
)
class MessageFormatterTestBase(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setup_db(self, results1, results2, with_steps=False, extra_build_properties=None):
if extra_build_properties is None:
extra_build_properties = {}
self.db = self.master.db
yield self.db.insert_test_data([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrkr'),
fakedb.Buildset(id=98, results=results1, reason="testReason1"),
fakedb.Buildset(id=99, results=results2, reason="testReason2"),
fakedb.SourceStamp(id=1, branch='master', revision='1234abcd'),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=1),
fakedb.BuildsetSourceStamp(buildsetid=99, sourcestampid=1),
fakedb.Builder(id=80, name='Builder1'),
fakedb.BuildRequest(id=11, buildsetid=98, builderid=80),
fakedb.BuildRequest(id=12, buildsetid=99, builderid=80),
fakedb.Build(
id=20,
number=0,
builderid=80,
buildrequestid=11,
workerid=13,
masterid=92,
results=results1,
),
fakedb.Build(
id=21,
number=1,
builderid=80,
buildrequestid=12,
workerid=13,
masterid=92,
results=results2,
),
])
for build_id in (20, 21):
yield self.db.insert_test_data([
fakedb.BuildProperty(buildid=build_id, name="workername", value="wrkr"),
fakedb.BuildProperty(buildid=build_id, name="reason", value="because"),
])
for name, value in extra_build_properties.items():
yield self.db.insert_test_data([
fakedb.BuildProperty(buildid=build_id, name=name, value=value),
])
if with_steps:
yield self.db.insert_test_data([
fakedb.Step(id=151, buildid=21, number=1, results=SUCCESS, name='first step'),
fakedb.Step(id=152, buildid=21, number=2, results=results2, name='second step'),
fakedb.Step(id=153, buildid=21, number=3, results=SUCCESS, name='third step'),
fakedb.Log(id=251, stepid=152, name='stdio', slug='stdio', type='s', num_lines=7),
fakedb.Log(id=252, stepid=152, name='stderr', slug='stderr', type='s', num_lines=7),
fakedb.Log(id=253, stepid=153, name='stdio', slug='stdio', type='s', num_lines=7),
])
@defer.inlineCallbacks
def do_one_test(
self,
formatter,
lastresults,
results,
mode="all",
with_steps=False,
extra_build_properties=None,
):
yield self.setup_db(
lastresults,
results,
with_steps=with_steps,
extra_build_properties=extra_build_properties,
)
res = yield utils.getDetailsForBuildset(
self.master,
99,
want_properties=formatter.want_properties,
want_steps=formatter.want_steps,
want_previous_build=True,
want_logs=formatter.want_logs,
want_logs_content=formatter.want_logs_content,
)
build = res['builds'][0]
res = yield formatter.format_message_for_build(
self.master, build, mode=mode, users=["him@bar", "me@foo"]
)
return res
@defer.inlineCallbacks
def do_one_test_buildset(
self,
formatter,
lastresults,
results,
mode="all",
with_steps=False,
extra_build_properties=None,
):
yield self.setup_db(
lastresults,
results,
with_steps=with_steps,
extra_build_properties=extra_build_properties,
)
res = yield utils.getDetailsForBuildset(
self.master,
99,
want_properties=formatter.want_properties,
want_steps=formatter.want_steps,
want_previous_build=True,
want_logs=formatter.want_logs,
want_logs_content=formatter.want_logs_content,
)
res = yield formatter.format_message_for_buildset(
self.master, res["buildset"], res["builds"], mode=mode, users=["him@bar", "me@foo"]
)
return res
class TestMessageFormatter(MessageFormatterTestBase):
def test_unknown_template_type_for_default_message(self):
with self.assertRaises(config.ConfigErrors):
message.MessageFormatter(template_type='unknown')
@defer.inlineCallbacks
def test_message_success_plain_no_steps(self):
formatter = message.MessageFormatter()
res = yield self.do_one_test(formatter, SUCCESS, SUCCESS)
self.assertEqual(
res,
{
'type': 'plain',
'subject': '☺ Buildbot (Buildbot): Builder1 - test ((unknown revision))',
"extra_info": None,
'body': textwrap.dedent("""\
A passing build has been detected on builder Builder1 while building proj.
Full details are available at:
http://localhost:8080/#/builders/80/builds/1
Build state: test
Revision: (unknown)
Worker: wrkr
Build Reason: because
Blamelist: him@bar, me@foo
Steps:
- (no steps)
"""),
},
)
@defer.inlineCallbacks
def test_message_success_plain_with_steps(self):
formatter = message.MessageFormatter()
res = yield self.do_one_test(
formatter,
SUCCESS,
SUCCESS,
with_steps=True,
extra_build_properties={'got_revision': 'abcd1234'},
)
self.assertEqual(
res,
{
'type': 'plain',
'subject': '☺ Buildbot (Buildbot): Builder1 - test (abcd1234)',
"extra_info": None,
'body': textwrap.dedent("""\
A passing build has been detected on builder Builder1 while building proj.
Full details are available at:
http://localhost:8080/#/builders/80/builds/1
Build state: test
Revision: abcd1234
Worker: wrkr
Build Reason: because
Blamelist: him@bar, me@foo
Steps:
- 1: first step ( success )
- 2: second step ( success )
Logs:
- stdio: http://localhost:8080/#/builders/80/builds/1/steps/2/logs/stdio
- stderr: http://localhost:8080/#/builders/80/builds/1/steps/2/logs/stderr
- 3: third step ( success )
Logs:
- stdio: http://localhost:8080/#/builders/80/builds/1/steps/3/logs/stdio
"""),
},
)
@defer.inlineCallbacks
def test_message_success_html(self):
formatter = message.MessageFormatter(template_type='html')
res = yield self.do_one_test(formatter, SUCCESS, SUCCESS)
self.assertEqual(
res,
{
'type': 'html',
'subject': '☺ Buildbot (Buildbot): Builder1 - test ((unknown revision))',
"extra_info": None,
'body': textwrap.dedent("""\
<p>A passing build has been detected on builder
<a href="http://localhost:8080/#/builders/80/builds/1">Builder1</a>
while building proj.</p>
<p>Information:</p>
<ul>
<li>Build state: test</li>
<li>Revision: (unknown)</li>
<li>Worker: wrkr</li>
<li>Build Reason: because</li>
<li>Blamelist: him@bar, me@foo</li>
</ul>
<p>Steps:</p>
<ul>
<li>No steps</li>
</ul>"""),
},
)
@defer.inlineCallbacks
def test_message_success_html_with_steps(self):
formatter = message.MessageFormatter(template_type='html')
res = yield self.do_one_test(
formatter,
SUCCESS,
SUCCESS,
with_steps=True,
extra_build_properties={'got_revision': 'abcd1234'},
)
self.assertEqual(
res,
{
'type': 'html',
'subject': '☺ Buildbot (Buildbot): Builder1 - test (abcd1234)',
"extra_info": None,
'body': textwrap.dedent("""\
<p>A passing build has been detected on builder
<a href="http://localhost:8080/#/builders/80/builds/1">Builder1</a>
while building proj.</p>
<p>Information:</p>
<ul>
<li>Build state: test</li>
<li>Revision: abcd1234</li>
<li>Worker: wrkr</li>
<li>Build Reason: because</li>
<li>Blamelist: him@bar, me@foo</li>
</ul>
<p>Steps:</p>
<ul>
<li style="">
1: first step ( success )
</li>
<li style="">
2: second step ( success )
(
<a href="http://localhost:8080/#/builders/80/builds/1/steps/2/logs/stdio"><stdio></a>
<a href="http://localhost:8080/#/builders/80/builds/1/steps/2/logs/stderr"><stderr></a>
)
</li>
<li style="">
3: third step ( success )
(
<a href="http://localhost:8080/#/builders/80/builds/1/steps/3/logs/stdio"><stdio></a>
)
</li>
</ul>"""),
},
)
@defer.inlineCallbacks
def test_inline_templates(self):
formatter = message.MessageFormatter(
template="URL: {{ build_url }} -- {{ summary }}", subject="subject"
)
res = yield self.do_one_test(formatter, SUCCESS, SUCCESS)
self.assertEqual(
res,
{
"type": "plain",
"subject": "subject",
"extra_info": None,
"body": "URL: http://localhost:8080/#/builders/80/builds/1 -- Build succeeded!",
},
)
@defer.inlineCallbacks
def test_inline_templates_extra_info(self):
formatter = message.MessageFormatter(
template="URL: {{ build_url }} -- {{ summary }}",
subject="subject",
extra_info_cb=lambda ctx: {"key1", ctx["build"]["state_string"]},
)
res = yield self.do_one_test(formatter, SUCCESS, SUCCESS)
self.assertEqual(
res,
{
"type": "plain",
"subject": "subject",
"extra_info": {"key1", "test"},
"body": "URL: http://localhost:8080/#/builders/80/builds/1 -- Build succeeded!",
},
)
@defer.inlineCallbacks
def test_message_failure(self):
formatter = message.MessageFormatter()
res = yield self.do_one_test(formatter, SUCCESS, FAILURE)
self.assertIn(
"A failed build has been detected on builder Builder1 while building", res['body']
)
@defer.inlineCallbacks
def test_message_failure_change(self):
formatter = message.MessageFormatter()
res = yield self.do_one_test(formatter, SUCCESS, FAILURE, "change")
self.assertIn(
"A new failure has been detected on builder Builder1 while building", res['body']
)
@defer.inlineCallbacks
def test_message_success_change(self):
formatter = message.MessageFormatter()
res = yield self.do_one_test(formatter, FAILURE, SUCCESS, "change")
self.assertIn(
"A restored build has been detected on builder Builder1 while building", res['body']
)
@defer.inlineCallbacks
def test_message_success_nochange(self):
formatter = message.MessageFormatter()
res = yield self.do_one_test(formatter, SUCCESS, SUCCESS, "change")
self.assertIn(
"A passing build has been detected on builder Builder1 while building", res['body']
)
@defer.inlineCallbacks
def test_message_failure_nochange(self):
formatter = message.MessageFormatter()
res = yield self.do_one_test(formatter, FAILURE, FAILURE, "change")
self.assertIn(
"A failed build has been detected on builder Builder1 while building", res['body']
)
class TestMessageFormatterRenderable(MessageFormatterTestBase):
@defer.inlineCallbacks
def test_basic(self):
template = Interpolate('templ_%(prop:workername)s/%(prop:reason)s')
subject = Interpolate('subj_%(prop:workername)s/%(prop:reason)s')
formatter = message.MessageFormatterRenderable(template, subject)
res = yield self.do_one_test(formatter, SUCCESS, SUCCESS)
self.assertEqual(
res,
{
'body': 'templ_wrkr/because',
'type': 'plain',
'subject': 'subj_wrkr/because',
"extra_info": None,
},
)
class TestMessageFormatterFunction(MessageFormatterTestBase):
@defer.inlineCallbacks
def test_basic(self):
function = mock.Mock(side_effect=lambda x: {'key': 'value'})
formatter = message.MessageFormatterFunction(function, 'json')
res = yield self.do_one_test(formatter, SUCCESS, SUCCESS)
function.assert_called_with({
'build': BuildDictLookAlike(
extra_keys=['prev_build'],
expected_missing_keys=['parentbuilder', 'buildrequest', 'parentbuild'],
)
})
self.assertEqual(
res,
{
'body': {'key': 'value'},
'type': 'json',
'subject': None,
"extra_info": None,
},
)
class TestMessageFormatterFunctionRaw(MessageFormatterTestBase):
@defer.inlineCallbacks
def test_basic(self):
function = mock.Mock(
side_effect=lambda master, ctx: {
"body": {"key": "value"},
"type": "json",
"subject": "sub1",
"extra_info": {"key": {"kk": "vv"}},
}
)
formatter = message.MessageFormatterFunctionRaw(function)
res = yield self.do_one_test(formatter, SUCCESS, SUCCESS)
self.assertEqual(
res,
{
"body": {"key": "value"},
"type": "json",
"subject": "sub1",
"extra_info": {"key": {"kk": "vv"}},
},
)
@defer.inlineCallbacks
def test_basic_buildset(self):
function = mock.Mock(
side_effect=lambda master, ctx: {
"body": {"key": "value"},
"type": "json",
"subject": "sub1",
"extra_info": {"key": {"kk": "vv"}},
}
)
formatter = message.MessageFormatterFunctionRaw(function)
res = yield self.do_one_test_buildset(formatter, SUCCESS, SUCCESS)
self.assertEqual(
res,
{
"body": {"key": "value"},
"type": "json",
"subject": "sub1",
"extra_info": {"key": {"kk": "vv"}},
},
)
class TestMessageFormatterMissingWorker(MessageFormatterTestBase):
@defer.inlineCallbacks
def test_basic(self):
formatter = message.MessageFormatterMissingWorker()
self.setup_db(SUCCESS, SUCCESS)
workers = yield self.master.data.get(('workers',))
worker = workers[0]
worker['notify'] = ['e@mail']
worker['last_connection'] = ['yesterday']
res = yield formatter.formatMessageForMissingWorker(self.master, worker)
text = res['body']
self.assertIn("worker named wrkr went away", text)
def test_unknown_template_type_for_default_message(self):
with self.assertRaises(config.ConfigErrors):
message.MessageFormatterMissingWorker(template_type='unknown')
| 23,411 | Python | .py | 564 | 29.973404 | 117 | 0.571535 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,453 | test_pushjet.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_pushjet.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
import os
from unittest import SkipTest
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.properties import Interpolate
from buildbot.process.results import SUCCESS
from buildbot.reporters.pushjet import PushjetNotifier
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.util import httpclientservice
class TestPushjetNotifier(ConfigErrorsMixin, TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
# returns a Deferred
def setupFakeHttp(self, base_url='https://api.pushjet.io'):
return fakehttpclientservice.HTTPClientService.getService(self.master, self, base_url)
@defer.inlineCallbacks
def setupPushjetNotifier(self, secret: Interpolate | None = None, **kwargs):
if secret is None:
secret = Interpolate("1234")
pn = PushjetNotifier(secret, **kwargs)
yield pn.setServiceParent(self.master)
yield pn.startService()
return pn
@defer.inlineCallbacks
def test_sendMessage(self):
_http = yield self.setupFakeHttp()
pn = yield self.setupPushjetNotifier(levels={'passing': 2})
_http.expect(
"post",
"/message",
data={'secret': "1234", 'level': 2, 'message': "Test", 'title': "Tee"},
content_json={'status': 'ok'},
)
n = yield pn.sendMessage([{"body": "Test", "subject": "Tee", "results": SUCCESS}])
j = yield n.json()
self.assertEqual(j['status'], 'ok')
@defer.inlineCallbacks
def test_sendNotification(self):
_http = yield self.setupFakeHttp('https://tests.io')
pn = yield self.setupPushjetNotifier(base_url='https://tests.io')
_http.expect(
"post",
"/message",
data={'secret': "1234", 'message': "Test"},
content_json={'status': 'ok'},
)
n = yield pn.sendNotification({'message': "Test"})
j = yield n.json()
self.assertEqual(j['status'], 'ok')
@defer.inlineCallbacks
def test_sendRealNotification(self):
secret = os.environ.get('TEST_PUSHJET_SECRET')
if secret is None:
raise SkipTest(
"real pushjet test runs only if the variable TEST_PUSHJET_SECRET is defined"
)
_http = yield httpclientservice.HTTPClientService.getService(
self.master, 'https://api.pushjet.io'
)
yield _http.startService()
pn = yield self.setupPushjetNotifier(secret=secret)
n = yield pn.sendNotification({'message': "Buildbot Pushjet test passed!"})
j = yield n.json()
self.assertEqual(j['status'], 'ok')
# Test with:
# TEST_PUSHJET_SECRET=edcfaf21ab1bbad7b12bd7602447e6cb
# https://api.pushjet.io/message?uuid=b8b8b8b8-0000-b8b8-0000-b8b8b8b8b8b8
| 4,037 | Python | .py | 90 | 38.177778 | 97 | 0.692523 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,454 | test_telegram.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_telegram.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
import json
import platform
import sys
from unittest.case import SkipTest
from twisted.internet import defer
from twisted.internet import reactor
from twisted.trial import unittest
from buildbot.plugins.db import get_plugins
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.reporters import telegram
from buildbot.reporters import words
from buildbot.schedulers import forcesched
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.fake.web import FakeRequest
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.unit.reporters.test_words import ContactMixin
from buildbot.util import httpclientservice
from buildbot.util import service
from buildbot.util import unicode2bytes
class FakeChannel(service.AsyncService):
pass
class FakeContact:
def __init__(self, user=None, channel=None):
super().__init__()
self.user_id = user['id']
self.user_info = user
self.channel = FakeChannel
self.channel.chat_info = channel.chat_info
self.template = None
self.messages = []
def handleMessage(self, message, **kwargs):
self.messages.append(message)
return defer.succeed(message)
class TestTelegramContact(ContactMixin, unittest.TestCase):
channelClass = telegram.TelegramChannel
contactClass = telegram.TelegramContact
class botClass(words.StatusBot):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.query_cache = {}
def send_message(self, chat, message, **kwargs):
return {'message_id': 123}
def edit_message(self, chat, msgid, message, **kwargs):
return {'message_id': 123}
def delete_message(self, chat, msgid):
pass
def send_sticker(self, chat, sticker, **kwargs):
pass
def edit_keyboard(self, chat, msg, keyboard=None):
pass
def getChannel(self, channel):
return self.channelClass(self, channel)
def post(self, path, **kwargs):
return True
USER: dict[str, str | int] = {
"id": 123456789,
"first_name": "Harry",
"last_name": "Potter",
"username": "harrypotter",
}
CHANNEL = {"id": -12345678, "title": "Hogwards", "type": "group"}
PRIVATE = {"id": 123456789, "type": "private"}
def patch_send(self):
self.sent = []
self.stickers = 0
def send_message(chat, message, **kwargs):
self.sent.append((chat, message, kwargs))
return {'message_id': 123}
self.bot.send_message = send_message
def send_sticker(chat, sticker, **kwargs):
self.stickers += 1
self.bot.send_sticker = send_sticker
@defer.inlineCallbacks
def setUp(self):
ContactMixin.setUp(self)
self.contact1 = self.contactClass(
user=self.USER, channel=self.channelClass(self.bot, self.PRIVATE)
)
yield self.contact1.channel.setServiceParent(self.master)
@defer.inlineCallbacks
def test_list_notified_events(self):
self.patch_send()
channel = telegram.TelegramChannel(self.bot, self.CHANNEL)
channel.notify_events = {'success'}
yield channel.list_notified_events()
self.assertEqual(
self.sent[0][1], "The following events are being notified:\nüîî **success**"
)
@defer.inlineCallbacks
def test_list_notified_events_empty(self):
self.patch_send()
channel = telegram.TelegramChannel(self.bot, self.CHANNEL)
channel.notify_events = set()
yield channel.list_notified_events()
self.assertEqual(self.sent[0][1], "üîï No events are being notified.")
def testDescribeUser(self):
self.assertEqual(self.contact1.describeUser(), "Harry Potter (@harrypotter)")
def testDescribeUserInGroup(self):
self.assertEqual(self.contact.describeUser(), "Harry Potter (@harrypotter) on 'Hogwards'")
@defer.inlineCallbacks
def test_access_denied(self):
self.patch_send()
self.contact1.ACCESS_DENIED_MESSAGES = ["ACCESS DENIED"]
yield self.contact1.access_denied(tmessage={'message_id': 123})
self.assertEqual("ACCESS DENIED", self.sent[0][1])
@defer.inlineCallbacks
def test_access_denied_group(self):
self.patch_send()
self.contact.ACCESS_DENIED_MESSAGES = ["ACCESS DENIED"]
yield self.contact.access_denied(tmessage={'message_id': 123})
self.assertEqual("ACCESS DENIED", self.sent[0][1])
def test_query_button_short(self):
result = self.contact.query_button("Hello", "hello")
self.assertEqual(result, {'text': "Hello", 'callback_data': "hello"})
def test_query_button_long(self):
payload = 16 * "1234567890"
key = hash(repr(payload))
result = self.contact.query_button("Hello", payload)
self.assertEqual(result, {'text': "Hello", 'callback_data': key})
self.assertEqual(self.bot.query_cache[key], payload)
def test_query_button_non_str(self):
payload = {'data': "good"}
key = hash(repr(payload))
result = self.contact.query_button("Hello", payload)
self.assertEqual(result, {'text': "Hello", 'callback_data': key})
self.assertEqual(self.bot.query_cache[key], payload)
def test_query_button_cache(self):
payload = 16 * "1234567890"
key = hash(repr(payload))
self.bot.query_cache[key] = payload
result = self.contact.query_button("Hello", payload)
self.assertEqual(result, {'text': "Hello", 'callback_data': key})
self.assertEqual(len(self.bot.query_cache), 1)
def test_query_button_cache_conflict(self):
payload = 16 * "1234567890"
key = hash(repr(payload))
self.bot.query_cache[key] = "something other"
result = self.contact.query_button("Hello", payload)
self.assertEqual(result, {'text': "Hello", 'callback_data': key + 1})
self.assertEqual(self.bot.query_cache[key + 1], payload)
@defer.inlineCallbacks
def test_command_start(self):
yield self.do_test_command('start', exp_usage=False)
self.assertEqual(self.sent[0][0], self.CHANNEL['id'])
@defer.inlineCallbacks
def test_command_nay(self):
yield self.do_test_command('nay', contact=self.contact1, tmessage={})
@defer.inlineCallbacks
def test_command_nay_reply_markup(self):
yield self.do_test_command(
'nay',
tmessage={
'reply_to_message': {
'message_id': 1234,
'reply_markup': {},
}
},
)
@defer.inlineCallbacks
def test_commmand_commands(self):
yield self.do_test_command('commands')
self.assertEqual(self.sent[0][0], self.CHANNEL['id'])
@defer.inlineCallbacks
def test_commmand_commands_botfather(self):
yield self.do_test_command('commands', 'botfather')
self.assertEqual(self.sent[0][0], self.CHANNEL['id'])
self.assertRegex(self.sent[0][1], r"^\w+ - \S+")
@defer.inlineCallbacks
def test_command_getid_private(self):
yield self.do_test_command('getid', contact=self.contact1)
self.assertEqual(len(self.sent), 1)
self.assertIn(str(self.USER['id']), self.sent[0][1])
@defer.inlineCallbacks
def test_command_getid_group(self):
yield self.do_test_command('getid')
self.assertIn(str(self.USER['id']), self.sent[0][1])
self.assertIn(str(self.CHANNEL['id']), self.sent[1][1])
def assertButton(self, data, pos=None, sent=0):
keyboard = self.sent[sent][2]['reply_markup']['inline_keyboard']
if pos is not None:
r, c = pos
self.assertEqual(keyboard[r][c]['callback_data'], data)
else:
dataset = [b['callback_data'] for row in keyboard for b in row]
self.assertIn(data, dataset)
@defer.inlineCallbacks
def test_command_list(self):
yield self.do_test_command('list')
self.assertButton('/list builders')
self.assertButton('/list workers')
self.assertButton('/list changes')
@defer.inlineCallbacks
def test_command_list_builders(self):
yield self.do_test_command('list', 'all builders')
self.assertEqual(len(self.sent), 1)
for builder in self.BUILDER_NAMES:
self.assertIn(f'`{builder}` ‚ùå', self.sent[0][1])
@defer.inlineCallbacks
def test_command_list_workers(self):
workers = ['worker1', 'worker2']
for worker in workers:
yield self.master.db.workers.db.insert_test_data([fakedb.Worker(name=worker)])
yield self.do_test_command('list', args='all workers')
self.assertEqual(len(self.sent), 1)
for worker in workers:
self.assertIn(f'`{worker}` ‚ùå', self.sent[0][1])
@defer.inlineCallbacks
def test_command_list_workers_online(self):
self.setup_multi_builders()
# Also set the connectedness:
yield self.master.db.insert_test_data([
fakedb.ConnectedWorker(id=113, masterid=13, workerid=1)
])
yield self.do_test_command('list', args='all workers')
self.assertEqual(len(self.sent), 1)
self.assertNotIn('`linux1` ⚠️', self.sent[0][1])
self.assertIn('`linux2` ⚠️', self.sent[0][1])
@defer.inlineCallbacks
def test_command_list_changes(self):
yield self.master.db.workers.db.insert_test_data([fakedb.Change()])
yield self.do_test_command('list', args='2 changes')
self.assertEqual(len(self.sent), 2)
@defer.inlineCallbacks
def test_command_list_changes_long(self):
yield self.master.db.workers.db.insert_test_data([fakedb.Change() for i in range(200)])
yield self.do_test_command('list', args='all changes')
self.assertIn('reply_markup', self.sent[1][2])
@defer.inlineCallbacks
def test_command_watch(self):
self.setupSomeBuilds()
yield self.do_test_command('watch')
self.assertButton('/watch builder1')
@defer.inlineCallbacks
def test_command_watch_no_builds(self):
yield self.do_test_command('watch')
@defer.inlineCallbacks
def test_command_stop_no_args(self):
self.setupSomeBuilds()
yield self.do_test_command('stop')
self.assertButton('/stop build builder1')
@defer.inlineCallbacks
def test_command_stop_ask_reason(self):
self.patch_send()
self.setupSomeBuilds()
yield self.do_test_command('stop', 'build builder1')
self.assertIn("give me the reason", self.sent[0][1])
self.assertEqual(self.contact.template, "/stop build builder1 {}")
def test_ask_reply_group(self):
self.patch_send()
self.contact.ask_for_reply("test")
self.assertEqual(self.sent[0][1], "Ok @harrypotter, now test...")
def test_ask_reply_group_no_username(self):
self.patch_send()
self.contact.user_info = self.USER.copy()
del self.contact.user_info['username']
self.contact.ask_for_reply("test")
self.assertEqual(self.sent[0][1], "Ok, now reply to this message and test...")
def test_ask_reply_group_no_username_no_greeting(self):
self.patch_send()
self.contact.user_info = self.USER.copy()
del self.contact.user_info['username']
self.contact.ask_for_reply("test", None)
self.assertEqual(self.sent[0][1], "Reply to this message and test...")
def test_ask_reply_private_no_greeting(self):
self.patch_send()
self.contact1.ask_for_reply("test", None)
self.assertEqual(self.sent[0][1], "Test...")
@defer.inlineCallbacks
def test_command_notify_no_args(self):
self.patch_send()
self.contact.channel.notify_events = {'success', 'failure'}
yield self.do_test_command('notify')
self.assertButton('/notify on-quiet finished')
self.assertButton('/notify off-quiet success')
self.assertButton('/notify list')
@defer.inlineCallbacks
def test_command_notify_list_with_query(self):
self.patch_send()
def delete_message(chat, msg):
delete_message.msg = msg
delete_message.msg = None
self.bot.delete_message = delete_message
yield self.do_test_command('notify', 'list', tquery={'message': {'message_id': 2345}})
self.assertEqual(delete_message.msg, 2345)
@defer.inlineCallbacks
def test_command_notify_toggle(self):
self.patch_send()
def edit_keyboard(chat, msg, keyboard):
self.sent.append((chat, None, {'reply_markup': {'inline_keyboard': keyboard}}))
self.bot.edit_keyboard = edit_keyboard
self.contact.channel.notify_events = {'success', 'failure'}
yield self.do_test_command(
'notify', 'on-quiet finished', tquery={'message': {'message_id': 2345}}
)
self.assertIn('finished', self.contact.channel.notify_events)
self.assertButton('/notify off-quiet finished')
@defer.inlineCallbacks
def test_command_shutdown(self):
yield self.do_test_command('shutdown')
self.assertButton('/shutdown start')
self.assertButton('/shutdown now')
@defer.inlineCallbacks
def test_command_shutdown_shutting_down(self):
yield self.do_test_command('shutdown', shuttingDown=True)
self.assertButton('/shutdown stop')
self.assertButton('/shutdown now')
def allSchedulers(self):
return self.schedulers
def make_forcescheduler(self, two=False):
scheduler = forcesched.ForceScheduler(
name='force1',
builderNames=['builder1', 'builder2'],
codebases=[
forcesched.CodebaseParameter(
'',
branch=forcesched.StringParameter(name='branch', default="master"),
repository=forcesched.FixedParameter(
name="repository", default="repository.git"
),
),
forcesched.CodebaseParameter(
'second',
branch=forcesched.StringParameter(name='branch', default="master"),
repository=forcesched.FixedParameter(
name="repository", default="repository2.git"
),
),
],
reason=forcesched.StringParameter(name='reason', required=True),
)
self.schedulers = [scheduler]
if two:
scheduler2 = forcesched.ForceScheduler(name='force2', builderNames=['builder2'])
self.schedulers.append(scheduler2)
self.bot.master.allSchedulers = self.allSchedulers
@defer.inlineCallbacks
def test_command_force_no_schedulers(self):
yield self.do_test_command('force', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_force_noargs_multiple_schedulers(self):
self.make_forcescheduler(two=True)
yield self.do_test_command('force')
self.assertButton('/force force1')
self.assertButton('/force force2')
@defer.inlineCallbacks
def test_command_force_noargs(self):
self.make_forcescheduler()
yield self.do_test_command('force')
self.assertButton('/force force1 config builder1')
self.assertButton('/force force1 config builder2')
@defer.inlineCallbacks
def test_command_force_only_scheduler(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'force1')
self.assertButton('/force force1 config builder1')
self.assertButton('/force force1 config builder2')
@defer.inlineCallbacks
def test_command_force_bad_scheduler(self):
self.make_forcescheduler(two=True)
yield self.do_test_command('force', 'force3', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_force_bad_builder(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'force1 config builder0', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_force_bad_command(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'force1 bad builder1', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_force_only_bad_command(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'bad builder1', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_force_config(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'force1 config builder1')
self.assertButton('/force force1 ask reason builder1 ')
self.assertButton('/force force1 ask branch builder1 ')
self.assertButton('/force force1 ask project builder1 ')
self.assertButton('/force force1 ask revision builder1 ')
self.assertButton('/force force1 ask second_branch builder1 ')
self.assertButton('/force force1 ask second_project builder1 ')
self.assertButton('/force force1 ask second_revision builder1 ')
@defer.inlineCallbacks
def test_command_force_config_more(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'force1 config builder1 branch=master')
self.assertButton('/force force1 ask reason builder1 branch=master')
@defer.inlineCallbacks
def test_command_force_config_nothing_missing(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'force1 config builder1 reason=Ok')
self.assertButton('/force force1 build builder1 reason=Ok')
@defer.inlineCallbacks
def test_command_force_ask(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'force1 ask reason builder1 branch=master')
self.assertEqual(
self.contact.template, '/force force1 config builder1 branch=master reason={}'
)
@defer.inlineCallbacks
def test_command_force_build_missing(self):
self.make_forcescheduler()
yield self.do_test_command('force', 'force1 build builder1')
self.assertButton('/force force1 ask reason builder1 ')
@defer.inlineCallbacks
def test_command_force_build(self):
self.make_forcescheduler()
force_args = {}
def force(**kwargs):
force_args.update(kwargs)
self.schedulers[0].force = force
yield self.do_test_command('force', 'force1 build builder1 reason=Good')
self.assertEqual(self.sent[0][1], "Force build successfully requested.")
expected = {
'builderid': 23,
'owner': "Harry Potter (@harrypotter) on 'Hogwards'",
'reason': 'Good',
'repository': 'repository.git', # fixed param
'second_repository': 'repository2.git', # fixed param
}
self.assertEqual(force_args, expected)
class TestPollingBot(telegram.TelegramPollingBot):
def __init__(self, updates, *args, **kwargs):
self.__updates = updates
super().__init__(*args, **kwargs)
def process_update(self, update):
self.__updates -= 1
if not self.__updates:
self._polling_continue = False
return super().process_update(update)
class TestTelegramService(TestReactorMixin, unittest.TestCase):
USER = TestTelegramContact.USER
CHANNEL = TestTelegramContact.CHANNEL
PRIVATE = TestTelegramContact.PRIVATE
URL = 'https://api.telegram.org/bot12345:secret'
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.patch(reactor, 'callLater', self.reactor.callLater)
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
self.http = None
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setup_http_service(self):
self.http = yield fakehttpclientservice.HTTPClientService.getService(
self.master, self, self.URL
)
def setup_http_session(self):
return httpclientservice.HTTPSession(self.master.httpservice, self.URL)
@defer.inlineCallbacks
def makeBot(self, chat_ids=None, authz=None, *args, **kwargs):
if chat_ids is None:
chat_ids = []
if self.http is None:
yield self.setup_http_service()
www = get_plugins('www', None, load_now=True)
if 'base' not in www:
raise SkipTest('telegram tests need buildbot-www installed')
return telegram.TelegramWebhookBot(
'12345:secret', self.setup_http_session(), chat_ids, authz, *args, **kwargs
)
@defer.inlineCallbacks
def test_getContact(self):
bot = yield self.makeBot()
c1 = bot.getContact(self.USER, self.PRIVATE)
c2 = bot.getContact(self.USER, self.CHANNEL)
c1b = bot.getContact(self.USER, self.PRIVATE)
self.assertIs(c1, c1b)
self.assertIsInstance(c2, words.Contact)
self.assertIn((-12345678, 123456789), bot.contacts)
self.assertEqual({123456789, -12345678}, set(bot.channels.keys()))
@defer.inlineCallbacks
def test_getContact_update(self):
try:
bot = yield self.makeBot()
contact = bot.getContact(self.USER, self.CHANNEL)
updated_user = self.USER.copy()
updated_user['username'] = "dirtyharry"
self.assertEqual(contact.user_info['username'], "harrypotter")
bot.getContact(updated_user, self.CHANNEL)
self.assertEqual(contact.user_info['username'], "dirtyharry")
finally:
self.USER['username'] = "harrypotter"
@defer.inlineCallbacks
def test_getContact_invalid(self):
bot = yield self.makeBot()
bot.authz = {'': None}
u = bot.getContact(user=self.USER, channel=self.CHANNEL)
self.assertNotIn((-12345678, 123456789), bot.contacts)
self.assertNotIn(-12345678, bot.channels)
if platform.python_implementation() != 'PyPy':
self.assertEqual(sys.getrefcount(u), 2) # local, sys
c = u.channel
self.assertEqual(sys.getrefcount(c), 3) # local, contact, sys
del u
self.assertEqual(sys.getrefcount(c), 2) # local, sys
@defer.inlineCallbacks
def test_getContact_valid(self):
bot = yield self.makeBot()
bot.authz = {'': None, 'command': 123456789}
bot.getContact(user=self.USER, channel=self.CHANNEL)
self.assertIn((-12345678, 123456789), bot.contacts)
@defer.inlineCallbacks
def test_set_webhook(self):
bot = yield self.makeBot()
self.http.expect("post", "/setWebhook", json={'url': 'our.webhook'}, content_json={'ok': 1})
yield bot.set_webhook('our.webhook')
@defer.inlineCallbacks
def test_set_webhook_cert(self):
bot = yield self.makeBot()
self.http.expect(
"post",
"/setWebhook",
data={'url': 'our.webhook'},
files={'certificate': b"this is certificate"},
content_json={'ok': 1},
)
yield bot.set_webhook('our.webhook', "this is certificate")
@defer.inlineCallbacks
def test_send_message(self):
bot = yield self.makeBot()
self.http.expect(
"post",
"/sendMessage",
json={'chat_id': 1234, 'text': 'Hello', 'parse_mode': 'Markdown'},
content_json={'ok': 1, 'result': {'message_id': 9876}},
)
m = yield bot.send_message(1234, 'Hello')
self.assertEqual(m['message_id'], 9876)
@defer.inlineCallbacks
def test_send_message_long(self):
bot = yield self.makeBot()
text1 = '\n'.join(f"{i + 1:039}" for i in range(102))
text2 = '\n'.join(f"{i + 1:039}" for i in range(102, 204))
text3 = '\n'.join(f"{i + 1:039}" for i in range(204, 250))
self.http.expect(
"post",
"/sendMessage",
json={
'chat_id': 1234,
'text': text1,
'parse_mode': 'Markdown',
'reply_to_message_id': 1000,
},
content_json={'ok': 1, 'result': {'message_id': 1001}},
)
self.http.expect(
"post",
"/sendMessage",
json={'chat_id': 1234, 'text': text2, 'parse_mode': 'Markdown'},
content_json={'ok': 1, 'result': {'message_id': 1002}},
)
self.http.expect(
"post",
"/sendMessage",
json={
'chat_id': 1234,
'text': text3,
'parse_mode': 'Markdown',
'reply_markup': {'inline_keyboard': 'keyboard'},
},
content_json={'ok': 1, 'result': {'message_id': 1003}},
)
text = '\n'.join(f"{i + 1:039}" for i in range(250))
m = yield bot.send_message(
1234, text, reply_markup={'inline_keyboard': 'keyboard'}, reply_to_message_id=1000
)
self.assertEqual(m['message_id'], 1003)
@defer.inlineCallbacks
def test_edit_message(self):
bot = yield self.makeBot()
self.http.expect(
"post",
"/editMessageText",
json={'chat_id': 1234, 'message_id': 9876, 'text': 'Hello', 'parse_mode': 'Markdown'},
content_json={'ok': 1, 'result': {'message_id': 9876}},
)
m = yield bot.edit_message(1234, 9876, 'Hello')
self.assertEqual(m['message_id'], 9876)
@defer.inlineCallbacks
def test_delete_message(self):
bot = yield self.makeBot()
self.http.expect(
"post",
"/deleteMessage",
json={'chat_id': 1234, 'message_id': 9876},
content_json={'ok': 1},
)
yield bot.delete_message(1234, 9876)
@defer.inlineCallbacks
def test_send_sticker(self):
bot = yield self.makeBot()
self.http.expect(
"post",
"/sendSticker",
json={'chat_id': 1234, 'sticker': 'xxxxx'},
content_json={'ok': 1, 'result': {'message_id': 9876}},
)
m = yield bot.send_sticker(1234, 'xxxxx')
self.assertEqual(m['message_id'], 9876)
@defer.inlineCallbacks
def test_set_nickname(self):
bot = yield self.makeBot()
self.assertIsNone(bot.nickname)
self.http.expect(
"post", "/getMe", content_json={'ok': 1, 'result': {'username': 'testbot'}}
)
yield bot.set_nickname()
self.assertEqual(bot.nickname, 'testbot')
def prepare_request(self, **kwargs):
payload = {"update_id": 12345}
payload.update(kwargs)
content = unicode2bytes(json.dumps(payload))
request = FakeRequest(content=content)
request.uri = b"/bot12345:secret"
request.method = b"POST"
request.received_headers[b'Content-Type'] = b"application/json"
return request
def request_message(self, text):
return self.prepare_request(
message={
"message_id": 123,
"from": self.USER,
"chat": self.CHANNEL,
"date": 1566688888,
"text": text,
}
)
def request_query(self, data):
return self.prepare_request(
callback_query={
"id": 123456,
"from": self.USER,
"data": data,
"message": {
"message_id": 12345,
"from": self.USER,
"chat": self.CHANNEL,
"date": 1566688888,
},
}
)
@defer.inlineCallbacks
def test_get_update(self):
bot = yield self.makeBot()
request = self.request_message("test")
update = bot.get_update(request)
self.assertEqual(update['message']['from'], self.USER)
self.assertEqual(update['message']['chat'], self.CHANNEL)
@defer.inlineCallbacks
def test_get_update_bad_content_type(self):
bot = yield self.makeBot()
request = self.request_message("test")
request.received_headers[b'Content-Type'] = b"application/data"
with self.assertRaises(ValueError):
bot.get_update(request)
@defer.inlineCallbacks
def test_render_POST(self):
# This actually also tests process_incoming
bot = yield self.makeBot()
bot.contactClass = FakeContact
request = self.request_message("test")
bot.webhook.render_POST(request)
contact = bot.getContact(self.USER, self.CHANNEL)
self.assertEqual(contact.messages, ["test"])
@defer.inlineCallbacks
def test_parse_query_cached(self):
bot = yield self.makeBot()
bot.contactClass = FakeContact
bot.query_cache.update({100: "good"})
self.http.expect(
"post",
"/answerCallbackQuery",
json={'callback_query_id': 123456},
content_json={'ok': 1},
)
request = self.request_query("100")
bot.process_webhook(request)
self.assertEqual(bot.getContact(self.USER, self.CHANNEL).messages, ["good"])
@defer.inlineCallbacks
def test_parse_query_cached_dict(self):
bot = yield self.makeBot()
bot.contactClass = FakeContact
bot.query_cache = {100: {'command': "good", 'notify': "hello"}}
self.http.expect(
"post",
"/answerCallbackQuery",
json={'callback_query_id': 123456, 'text': "hello"},
content_json={'ok': 1},
)
request = self.request_query("100")
bot.process_webhook(request)
self.assertEqual(bot.getContact(self.USER, self.CHANNEL).messages, ["good"])
@defer.inlineCallbacks
def test_parse_query_explicit(self):
bot = yield self.makeBot()
bot.contactClass = FakeContact
bot.query_cache = {100: "bad"}
self.http.expect(
"post",
"/answerCallbackQuery",
json={'callback_query_id': 123456},
content_json={'ok': 1},
)
request = self.request_query("good")
bot.process_webhook(request)
self.assertEqual(bot.getContact(self.USER, self.CHANNEL).messages, ["good"])
@defer.inlineCallbacks
def test_parse_query_bad(self):
bot = yield self.makeBot()
bot.contactClass = FakeContact
bot.query_cache.update({100: "bad"})
self.http.expect(
"post",
"/editMessageReplyMarkup",
json={'chat_id': -12345678, 'message_id': 12345},
content_json={'ok': 1},
)
self.http.expect(
"post",
"/answerCallbackQuery",
json={'callback_query_id': 123456, 'text': "Sorry, button is no longer valid!"},
content_json={'ok': 1},
)
request = self.request_query("101")
bot.process_webhook(request)
def makePollingBot(self, updates, chat_ids=None, authz=None, *args, **kwargs):
if chat_ids is None:
chat_ids = []
return TestPollingBot(
updates, '12345:secret', self.setup_http_session(), chat_ids, authz, *args, **kwargs
)
@defer.inlineCallbacks
def test_polling(self):
yield self.setup_http_service()
bot = self.makePollingBot(2)
bot._polling_continue = True
self.http.expect("post", "/deleteWebhook", content_json={"ok": 1})
self.http.expect(
"post",
"/getUpdates",
json={'timeout': bot.poll_timeout},
content_json={
'ok': 1,
'result': [
{
"update_id": 10000,
"message": {
"message_id": 123,
"from": self.USER,
"chat": self.CHANNEL,
"date": 1566688888,
"text": "ignore",
},
}
],
},
)
self.http.expect(
"post",
"/getUpdates",
json={'timeout': bot.poll_timeout, "offset": 10001},
content_json={
'ok': 1,
'result': [
{
"update_id": 10001,
"message": {
"message_id": 124,
"from": self.USER,
"chat": self.CHANNEL,
"date": 1566688889,
"text": "/nay",
},
}
],
},
)
self.http.expect(
"post",
"/sendMessage",
json={'chat_id': -12345678, 'text': 'Never mind, Harry...', 'parse_mode': 'Markdown'},
content_json={'ok': 1, 'result': {'message_id': 125}},
)
yield bot.do_polling()
@defer.inlineCallbacks
def test_format_build_status(self):
bot = yield self.makeBot()
build = {'results': SUCCESS}
self.assertEqual(bot.format_build_status(build), "completed successfully ‚úÖ")
@defer.inlineCallbacks
def test_format_build_status_short(self):
bot = yield self.makeBot()
build = {'results': WARNINGS}
self.assertEqual(bot.format_build_status(build, short=True), " ⚠️")
class HttpServiceWithErrors(fakehttpclientservice.HTTPClientService):
def __init__(self, skip, errs, *args, **kwargs):
self.__skip = skip
self.__errs = errs
self.succeeded = False
super().__init__(*args, **kwargs)
def _do_request(self, session, method, ep, **kwargs):
if method == 'post':
if self.__skip:
self.__skip -= 1
else:
if self.__errs:
self.__errs -= 1
raise RuntimeError(f"{self.__errs + 1}")
self.succeeded = True
return super()._do_request(session, method, ep, **kwargs)
# returns a Deferred
@defer.inlineCallbacks
def setup_http_service_with_errors(self, skip, errs):
url = 'https://api.telegram.org/bot12345:secret'
self.http = yield self.HttpServiceWithErrors.getService(self.master, self, skip, errs, url)
@defer.inlineCallbacks
def test_post_not_ok(self):
bot = yield self.makeBot()
self.http.expect("post", "/post", content_json={'ok': 0})
def log(msg):
logs.append(msg)
logs = []
bot.log = log
yield bot.post("/post")
self.assertIn("ERROR", logs[0])
@defer.inlineCallbacks
def test_post_need_repeat(self):
yield self.setup_http_service_with_errors(0, 2)
bot = yield self.makeBot()
self.http.expect("post", "/post", content_json={'ok': 1})
def log(msg):
logs.append(msg)
logs = []
bot.log = log
bot.post("/post")
self.assertIn("ERROR", logs[0])
self.reactor.pump(3 * [30.0])
self.assertTrue(self.http.succeeded)
@defer.inlineCallbacks
def test_polling_need_repeat(self):
yield self.setup_http_service_with_errors(1, 2)
bot = self.makePollingBot(1)
bot.reactor = self.reactor
bot._polling_continue = True
self.http.expect("post", "/deleteWebhook", content_json={"ok": 1})
self.http.expect(
"post",
"/getUpdates",
json={'timeout': bot.poll_timeout},
content_json={
'ok': 1,
'result': [
{
"update_id": 10000,
"message": {
"message_id": 123,
"from": self.USER,
"chat": self.CHANNEL,
"date": 1566688888,
"text": "ignore",
},
}
],
},
)
def log(msg):
logs.append(msg)
logs = []
bot.log = log
bot.do_polling()
self.assertIn("ERROR", logs[0])
self.reactor.pump(3 * [30.0])
self.assertTrue(self.http.succeeded)
| 37,700 | Python | .py | 895 | 32.255866 | 100 | 0.603318 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,455 | test_bitbucket.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_bitbucket.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.properties import Interpolate
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.reporters.bitbucket import _BASE_URL
from buildbot.reporters.bitbucket import _OAUTH_URL
from buildbot.reporters.bitbucket import BitbucketStatusPush
from buildbot.reporters.generators.build import BuildStartEndStatusGenerator
from buildbot.reporters.message import MessageFormatter
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.logging import LoggingMixin
from buildbot.test.util.reporter import ReporterTestMixin
from buildbot.util import httpclientservice
class TestBitbucketStatusPush(
TestReactorMixin, unittest.TestCase, ConfigErrorsMixin, ReporterTestMixin, LoggingMixin
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.reporter_test_repo = 'https://example.org/user/repo'
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
self._http = yield fakehttpclientservice.HTTPClientService.getService(self.master, self, "")
self.httpsession = httpclientservice.HTTPSession(
None, _BASE_URL, auth=None, debug=None, verify=None
)
self.httpsession.update_headers({'Authorization': 'Bearer foo'})
self.oauthsession = httpclientservice.HTTPSession(
None, _OAUTH_URL, auth=('key', 'secret'), debug=None, verify=None
)
self.bsp = BitbucketStatusPush(Interpolate('key'), Interpolate('secret'))
yield self.bsp.setServiceParent(self.master)
yield self.bsp.startService()
@defer.inlineCallbacks
def tearDown(self):
yield self.bsp.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_basic(self):
build = yield self.insert_build_new()
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self._http.expect(
'post',
'/user/repo/commit/d34db33fd43db33f/statuses/build',
session=self.httpsession,
json={
'state': 'INPROGRESS',
'key': '0550a051225ac4ea91a92c9c94d41dfe6fa9f428', # sha1("Builder0")
'name': 'Builder0',
'description': '',
'url': 'http://localhost:8080/#/builders/79/builds/0',
},
code=201,
)
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self._http.expect(
'post',
'/user/repo/commit/d34db33fd43db33f/statuses/build',
session=self.httpsession,
json={
'state': 'SUCCESSFUL',
'key': '0550a051225ac4ea91a92c9c94d41dfe6fa9f428', # sha1("Builder0")
'name': 'Builder0',
'description': '',
'url': 'http://localhost:8080/#/builders/79/builds/0',
},
code=201,
)
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self._http.expect(
'post',
'/user/repo/commit/d34db33fd43db33f/statuses/build',
session=self.httpsession,
json={
'state': 'FAILED',
'key': '0550a051225ac4ea91a92c9c94d41dfe6fa9f428', # sha1("Builder0")
'name': 'Builder0',
'description': '',
'url': 'http://localhost:8080/#/builders/79/builds/0',
},
code=201,
)
yield self.bsp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.bsp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.bsp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_success_return_codes(self):
build = yield self.insert_build_finished(SUCCESS)
# make sure a 201 return code does not trigger an error
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self._http.expect(
'post',
'/user/repo/commit/d34db33fd43db33f/statuses/build',
session=self.httpsession,
json={
'state': 'SUCCESSFUL',
'key': '0550a051225ac4ea91a92c9c94d41dfe6fa9f428', # sha1("Builder0")
'name': 'Builder0',
'description': '',
'url': 'http://localhost:8080/#/builders/79/builds/0',
},
code=201,
)
self.setUpLogging()
yield self.bsp._got_event(('builds', 20, 'finished'), build)
self.assertNotLogged('201: unable to upload Bitbucket status')
# make sure a 200 return code does not trigger an error
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self._http.expect(
'post',
'/user/repo/commit/d34db33fd43db33f/statuses/build',
session=self.httpsession,
json={
'state': 'SUCCESSFUL',
'key': '0550a051225ac4ea91a92c9c94d41dfe6fa9f428', # sha1("Builder0")
'name': 'Builder0',
'description': '',
'url': 'http://localhost:8080/#/builders/79/builds/0',
},
code=200,
)
self.setUpLogging()
yield self.bsp._got_event(('builds', 20, 'finished'), build)
self.assertNotLogged('200: unable to upload Bitbucket status')
@defer.inlineCallbacks
def test_unable_to_authenticate(self):
build = yield self.insert_build_new()
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={
"error_description": "Unsupported grant type: None",
"error": "invalid_grant",
},
code=400,
)
self.setUpLogging()
yield self.bsp._got_event(('builds', 20, 'new'), build)
self.assertLogged('400: unable to authenticate to Bitbucket')
@defer.inlineCallbacks
def test_unable_to_send_status(self):
build = yield self.insert_build_new()
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self._http.expect(
'post',
'/user/repo/commit/d34db33fd43db33f/statuses/build',
session=self.httpsession,
json={
'state': 'INPROGRESS',
'key': '0550a051225ac4ea91a92c9c94d41dfe6fa9f428', # sha1("Builder0")
'name': 'Builder0',
'description': '',
'url': 'http://localhost:8080/#/builders/79/builds/0',
},
code=404,
content_json={
"error_description": "This commit is unknown to us",
"error": "invalid_commit",
},
)
self.setUpLogging()
yield self.bsp._got_event(('builds', 20, 'new'), build)
self.assertLogged('404: unable to upload Bitbucket status')
self.assertLogged('This commit is unknown to us')
self.assertLogged('invalid_commit')
@defer.inlineCallbacks
def test_empty_repository(self):
self.reporter_test_repo = ''
build = yield self.insert_build_new()
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self.setUpLogging()
yield self.bsp._got_event(('builds', 20, 'new'), build)
self.assertLogged('Empty repository URL for Bitbucket status')
class TestBitbucketStatusPushProperties(
TestReactorMixin, unittest.TestCase, ConfigErrorsMixin, ReporterTestMixin, LoggingMixin
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.reporter_test_repo = 'https://example.org/user/repo'
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master,
self,
"",
)
self.httpsession = httpclientservice.HTTPSession(
None, _BASE_URL, auth=None, debug=None, verify=None
)
self.httpsession.update_headers({'Authorization': 'Bearer foo'})
self.oauthsession = httpclientservice.HTTPSession(
None, _OAUTH_URL, auth=('key', 'secret'), debug=None, verify=None
)
self.bsp = BitbucketStatusPush(
Interpolate('key'),
Interpolate('secret'),
status_key=Interpolate("%(prop:buildername)s/%(prop:buildnumber)s"),
status_name=Interpolate("%(prop:buildername)s-%(prop:buildnumber)s"),
generators=[
BuildStartEndStatusGenerator(
start_formatter=MessageFormatter(subject="{{ status_detected }}"),
end_formatter=MessageFormatter(subject="{{ summary }}"),
)
],
)
yield self.bsp.setServiceParent(self.master)
yield self.bsp.startService()
@defer.inlineCallbacks
def tearDown(self):
yield self.bsp.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_properties(self):
build = yield self.insert_build_new()
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self._http.expect(
'post',
'/user/repo/commit/d34db33fd43db33f/statuses/build',
session=self.httpsession,
json={
'state': 'INPROGRESS',
'key': '84f9e75c46896d56da4fd75e096d24ec62f76f33', # sha1("Builder0/0")
'name': 'Builder0-0',
'description': 'not finished build',
'url': 'http://localhost:8080/#/builders/79/builds/0',
},
code=201,
)
self._http.expect(
'post',
'',
session=self.oauthsession,
data={'grant_type': 'client_credentials'},
content_json={'access_token': 'foo'},
)
self._http.expect(
'post',
'/user/repo/commit/d34db33fd43db33f/statuses/build',
session=self.httpsession,
json={
'state': 'SUCCESSFUL',
'key': '84f9e75c46896d56da4fd75e096d24ec62f76f33', # sha1("Builder0/0")
'name': 'Builder0-0',
'description': 'Build succeeded!',
'url': 'http://localhost:8080/#/builders/79/builds/0',
},
code=201,
)
yield self.bsp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.bsp._got_event(('builds', 20, 'finished'), build)
class TestBitbucketStatusPushConfig(ConfigErrorsMixin, unittest.TestCase):
def test_auth_error(self):
with self.assertRaisesConfigError(
"Either App Passwords or OAuth can be specified, not both"
):
BitbucketStatusPush(oauth_key='abc', oauth_secret='abc1', auth=('user', 'pass'))
class TestBitbucketStatusPushRepoParsing(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
self.bsp = BitbucketStatusPush(Interpolate('key'), Interpolate('secret'))
yield self.bsp.setServiceParent(self.master)
yield self.bsp.startService()
@defer.inlineCallbacks
def tearDown(self):
yield self.bsp.stopService()
yield self.tear_down_test_reactor()
def parse(self, repourl):
return tuple(self.bsp.get_owner_and_repo(repourl))
def test_parse_no_scheme(self):
self.assertEqual(('user', 'repo'), self.parse('[email protected]:user/repo.git'))
self.assertEqual(('user', 'repo'), self.parse('[email protected]:user/repo'))
def test_parse_with_scheme(self):
self.assertEqual(('user', 'repo'), self.parse('https://bitbucket.com/user/repo.git'))
self.assertEqual(('user', 'repo'), self.parse('https://bitbucket.com/user/repo'))
self.assertEqual(('user', 'repo'), self.parse('ssh://[email protected]/user/repo.git'))
self.assertEqual(('user', 'repo'), self.parse('ssh://[email protected]/user/repo'))
self.assertEqual(
('user', 'repo'), self.parse('https://api.bitbucket.org/2.0/repositories/user/repo')
)
| 14,911 | Python | .py | 355 | 31.594366 | 100 | 0.599076 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,456 | test_words.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_words.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
import re
from typing import Any
from typing import Callable
from typing import Generator
from unittest import mock
from twisted.internet import defer
from twisted.internet import reactor
from twisted.trial import unittest
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.reporters import words
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.util import datetime2epoch
class ContactMixin(TestReactorMixin):
botClass = words.StatusBot
channelClass = words.Channel
contactClass = words.Contact
USER: Any = "me"
CHANNEL: Any = "#buildbot"
BUILDER_NAMES = ['builder1', 'builder2']
BUILDER_IDS = [23, 45]
patch: Callable[[Any, str, Any], Any]
@defer.inlineCallbacks
def setUp(self) -> Generator[Any, None, None]:
self.setup_test_reactor(auto_tear_down=False)
self.patch(reactor, 'callLater', self.reactor.callLater)
self.patch(reactor, 'seconds', self.reactor.seconds)
self.patch(reactor, 'stop', self.reactor.stop)
self.master = yield fakemaster.make_master(self, wantMq=True, wantData=True, wantDb=True)
yield self.master.db.insert_test_data([
fakedb.Builder(id=builderid, name=name)
for builderid, name in zip(self.BUILDER_IDS, self.BUILDER_NAMES)
])
self.bot = self.botClass(notify_events={'success': 1, 'failure': 1})
self.bot.channelClass = self.channelClass
self.bot.contactClass = self.contactClass
self.bot.nickname = 'nick'
self.missing_workers: set[int] = set()
# fake out subscription/unsubscription
self.subscribed = False
# fake out clean shutdown
self.bot.parent = self # type: ignore[assignment]
self.bot.master.botmaster = mock.Mock(name='StatusBot-instance.master.botmaster')
self.bot.master.botmaster.shuttingDown = False
def cleanShutdown():
self.bot.master.botmaster.shuttingDown = True
self.bot.master.botmaster.cleanShutdown = cleanShutdown
def cancelCleanShutdown():
self.bot.master.botmaster.shuttingDown = False
self.bot.master.botmaster.cancelCleanShutdown = cancelCleanShutdown
self.contact = self.contactClass(user=self.USER, channel=self.bot.getChannel(self.CHANNEL))
yield self.contact.channel.setServiceParent(self.master)
yield self.master.startService()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def patch_send(self):
self.sent = []
def send(msg):
if not isinstance(msg, (list, tuple)):
msg = (msg,)
for m in msg:
self.sent.append(m)
self.contact.channel.send = send
@defer.inlineCallbacks
def do_test_command(
self,
command,
args='',
contact=None,
clock_ticks=None,
exp_usage=True,
exp_UsageError=False,
shuttingDown=False,
**kwargs,
):
if contact is None:
contact = self.contact
cmd = getattr(contact, 'command_' + command.upper())
if exp_usage:
self.assertTrue(hasattr(cmd, 'usage'))
self.patch_send()
self.bot.master.botmaster.shuttingDown = shuttingDown
if exp_UsageError:
try:
yield cmd(args, **kwargs)
except words.UsageError:
return
else:
self.fail("no UsageError")
else:
yield cmd(args, **kwargs)
if clock_ticks:
self.reactor.pump(clock_ticks)
@defer.inlineCallbacks
def setupSomeBuilds(self):
yield self.master.db.insert_test_data([
# Three builds on builder#0, One build on builder#1
fakedb.Build(
id=13,
masterid=88,
workerid=13,
builderid=self.BUILDER_IDS[0],
buildrequestid=82,
number=3,
),
fakedb.Build(
id=14,
masterid=88,
workerid=13,
builderid=self.BUILDER_IDS[0],
buildrequestid=83,
number=4,
),
fakedb.Build(
id=15,
masterid=88,
workerid=13,
builderid=self.BUILDER_IDS[1],
buildrequestid=84,
number=5,
),
fakedb.Build(
id=16,
masterid=88,
workerid=13,
builderid=self.BUILDER_IDS[0],
buildrequestid=85,
number=6,
),
])
self.master.db.builds.finishBuild(buildid=14, results=SUCCESS)
@defer.inlineCallbacks
def setup_multi_builders(self):
# Make first builder configured, but not connected
# Make second builder configured and connected
yield self.master.db.insert_test_data([
fakedb.Worker(id=1, name='linux1', info={}), # connected one
fakedb.Worker(id=2, name='linux2', info={}), # disconnected one
fakedb.BuilderMaster(id=4012, masterid=13, builderid=self.BUILDER_IDS[0]),
fakedb.BuilderMaster(id=4013, masterid=13, builderid=self.BUILDER_IDS[1]),
fakedb.ConfiguredWorker(id=14013, workerid=2, buildermasterid=4012),
fakedb.ConfiguredWorker(id=14014, workerid=1, buildermasterid=4013),
])
class TestContact(ContactMixin, unittest.TestCase): # type: ignore[misc]
def test_channel_service(self):
self.assertTrue(self.contact.channel.running)
self.contact.channel.stopService()
@defer.inlineCallbacks
def test_command_notify0(self):
yield self.do_test_command('notify', exp_UsageError=True)
yield self.do_test_command('notify', args="invalid arg", exp_UsageError=True)
yield self.do_test_command('notify', args="on")
self.assertEqual(self.sent, ["The following events are being notified: finished, started."])
yield self.do_test_command('notify', args="off")
self.assertEqual(self.sent, ['No events are being notified.'])
yield self.do_test_command('notify', args="on started")
self.assertEqual(self.sent, ["The following events are being notified: started."])
yield self.do_test_command('notify', args="off started")
self.assertEqual(self.sent, ['No events are being notified.'])
yield self.assertFailure(self.do_test_command('notify', args="off finished"), KeyError)
yield self.do_test_command('notify', args="list")
self.assertEqual(self.sent, ['No events are being notified.'])
@defer.inlineCallbacks
def notify_build_test(self, notify_args):
self.bot.tags = None
yield self.test_command_watch_builder0()
yield self.do_test_command('notify', args=notify_args)
buildStarted = self.contact.channel.subscribed[0].callback
buildFinished = self.contact.channel.subscribed[1].callback
for buildid in (13, 14, 16):
self.master.db.builds.finishBuild(buildid=buildid, results=SUCCESS)
build = yield self.master.data.get(('builds', buildid))
buildStarted("somekey", build)
buildFinished("somekey", build)
def test_command_notify_build_started(self):
self.notify_build_test("on started")
def test_command_notify_build_finished(self):
self.notify_build_test("on finished")
def test_command_notify_build_better(self):
self.notify_build_test("on better")
def test_command_notify_build_worse(self):
self.notify_build_test("on worse")
def test_command_notify_build_problem(self):
self.notify_build_test("on problem")
def test_command_notify_build_recovery(self):
self.notify_build_test("on recovery")
def test_command_notify_build_started_finished(self):
self.notify_build_test("on")
@defer.inlineCallbacks
def test_notify_missing_worker(self):
self.patch_send()
yield self.do_test_command('notify', args='on worker')
missing_worker = self.contact.channel.subscribed[2].callback
missing_worker(
(None, None, 'missing'), {"workerid": 1, "name": 'work', "last_connection": 'sometime'}
)
self.assertEqual(self.sent[1], "Worker `work` is missing. It was seen last on sometime.")
self.assertIn(1, self.contact.channel.missing_workers)
@defer.inlineCallbacks
def test_notify_worker_is_back(self):
self.patch_send()
yield self.do_test_command('notify', args='on worker')
self.contact.channel.missing_workers.add(1)
missing_worker = self.contact.channel.subscribed[2].callback
missing_worker(
(None, None, 'connected'),
{"workerid": 1, "name": 'work', "last_connection": 'sometime'},
)
self.assertEqual(self.sent[1], "Worker `work` is back online.")
self.assertNotIn(1, self.contact.channel.missing_workers)
@defer.inlineCallbacks
def test_command_help_noargs(self):
yield self.do_test_command('help')
self.assertIn('help - ', '\n'.join(self.sent))
@defer.inlineCallbacks
def test_command_help_arg(self):
self.contact.command_FOO = lambda: None
self.contact.command_FOO.usage = 'foo - bar'
yield self.do_test_command('help', args='foo')
self.assertIn('Usage: foo - bar', self.sent[0])
@defer.inlineCallbacks
def test_command_help_no_usage(self):
self.contact.command_FOO = lambda: None
yield self.do_test_command('help', args='foo')
self.assertIn('No usage info for', self.sent[0])
@defer.inlineCallbacks
def test_command_help_dict_command(self):
self.contact.command_FOO = lambda: None
self.contact.command_FOO.usage = {None: 'foo - bar'}
yield self.do_test_command('help', args='foo')
self.assertIn('Usage: foo - bar', self.sent[0])
@defer.inlineCallbacks
def test_command_help_dict_command_no_usage(self):
self.contact.command_FOO = lambda: None
self.contact.command_FOO.usage = {}
yield self.do_test_command('help', args='foo')
self.assertIn("No usage info for 'foo'", self.sent[0])
@defer.inlineCallbacks
def test_command_help_dict_command_arg(self):
self.contact.command_FOO = lambda: None
self.contact.command_FOO.usage = {'this': 'foo this - bar'}
yield self.do_test_command('help', args='foo this')
self.assertIn('Usage: foo this - bar', self.sent[0])
@defer.inlineCallbacks
def test_command_help_dict_command_arg_no_usage(self):
self.contact.command_FOO = lambda: None
self.contact.command_FOO.usage = {
# nothing for arg 'this'
('this', 'first'): 'foo this first - bar'
}
yield self.do_test_command('help', args='foo this')
self.assertIn("No usage info for 'foo' 'this'", self.sent[0])
@defer.inlineCallbacks
def test_command_help_dict_command_arg_subarg(self):
self.contact.command_FOO = lambda: None
self.contact.command_FOO.usage = {('this', 'first'): 'foo this first - bar'}
yield self.do_test_command('help', args='foo this first')
self.assertIn('Usage: foo this first - bar', self.sent[0])
@defer.inlineCallbacks
def test_command_help_dict_command_arg_subarg_no_usage(self):
self.contact.command_FOO = lambda: None
self.contact.command_FOO.usage = {
None: 'foo - bar',
'this': 'foo this - bar',
('this', 'first'): 'foo this first - bar',
# nothing for subarg 'missing'
}
yield self.do_test_command('help', args='foo this missing')
self.assertIn("No usage info for 'foo' 'this' 'missing'", self.sent[0])
@defer.inlineCallbacks
def test_command_help_nosuch(self):
yield self.do_test_command('help', args='foo', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_shutdown(self):
yield self.do_test_command('shutdown', exp_UsageError=True)
self.assertEqual(self.bot.master.botmaster.shuttingDown, False)
@defer.inlineCallbacks
def test_command_shutdown_check_running(self):
yield self.do_test_command('shutdown', args='check', shuttingDown=False)
self.assertEqual(self.bot.master.botmaster.shuttingDown, False)
self.assertIn('buildbot is running', self.sent[0])
@defer.inlineCallbacks
def test_command_shutdown_check_shutting_down(self):
yield self.do_test_command('shutdown', args='check', shuttingDown=True)
self.assertEqual(self.bot.master.botmaster.shuttingDown, True)
self.assertIn('buildbot is shutting down', self.sent[0])
@defer.inlineCallbacks
def test_command_shutdown_start(self):
yield self.do_test_command('shutdown', args='start', shuttingDown=False)
self.assertEqual(self.bot.master.botmaster.shuttingDown, True)
@defer.inlineCallbacks
def test_command_shutdown_stop(self):
yield self.do_test_command('shutdown', args='stop', shuttingDown=True)
self.assertEqual(self.bot.master.botmaster.shuttingDown, False)
@defer.inlineCallbacks
def test_command_shutdown_now(self):
yield self.do_test_command('shutdown', args='now')
self.assertEqual(self.bot.master.botmaster.shuttingDown, False)
self.assertTrue(self.reactor.stop_called)
@defer.inlineCallbacks
def test_command_source(self):
yield self.do_test_command('source')
self.assertIn('My source', self.sent[0])
@defer.inlineCallbacks
def test_command_commands(self):
yield self.do_test_command('commands')
self.assertIn('Buildbot commands', self.sent[0])
@defer.inlineCallbacks
def test_command_hello(self):
yield self.do_test_command('hello', exp_usage=False)
self.assertIn(self.sent[0], words.GREETINGS)
@defer.inlineCallbacks
def test_command_list(self):
yield self.do_test_command('list', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_list_builders(self):
yield self.do_test_command('list', args='all builders')
self.assertEqual(len(self.sent), 1)
for builder in self.BUILDER_NAMES:
self.assertIn(f'{builder} [offline]', self.sent[0])
@defer.inlineCallbacks
def test_command_list_workers(self):
workers = ['worker1', 'worker2']
for worker in workers:
yield self.master.db.workers.db.insert_test_data([fakedb.Worker(name=worker)])
yield self.do_test_command('list', args='all workers')
self.assertEqual(len(self.sent), 1)
for worker in workers:
self.assertIn(f'{worker} [offline]', self.sent[0])
@defer.inlineCallbacks
def test_command_list_workers_online(self):
yield self.setup_multi_builders()
# Also set the connectedness:
yield self.master.db.insert_test_data([
fakedb.ConnectedWorker(id=113, masterid=13, workerid=1)
])
yield self.do_test_command('list', args='all workers')
self.assertEqual(len(self.sent), 1)
self.assertNotIn('linux1 [disconnected]', self.sent[0])
self.assertIn('linux2 [disconnected]', self.sent[0])
@defer.inlineCallbacks
def test_command_list_changes(self):
yield self.master.db.workers.db.insert_test_data([fakedb.Change()])
yield self.do_test_command('list', args='2 changes')
self.assertEqual(len(self.sent), 1)
@defer.inlineCallbacks
def test_command_list_builders_not_connected(self):
yield self.setup_multi_builders()
yield self.do_test_command('list', args='all builders')
self.assertEqual(len(self.sent), 1)
self.assertIn(f'{self.BUILDER_NAMES[0]} [offline]', self.sent[0])
self.assertIn(f'{self.BUILDER_NAMES[1]} [offline]', self.sent[0])
@defer.inlineCallbacks
def test_command_list_builders_connected(self):
yield self.setup_multi_builders()
# Also set the connectedness:
yield self.master.db.insert_test_data([
fakedb.ConnectedWorker(id=113, masterid=13, workerid=1)
])
yield self.do_test_command('list', args='all builders')
self.assertEqual(len(self.sent), 1)
self.assertIn(f'{self.BUILDER_NAMES[0]} [offline]', self.sent[0])
self.assertNotIn(f'{self.BUILDER_NAMES[1]} [offline]', self.sent[0])
@defer.inlineCallbacks
def test_command_status(self):
yield self.do_test_command('status')
@defer.inlineCallbacks
def test_command_status_online(self):
# we are online and we have some finished builds
yield self.setup_multi_builders()
yield self.master.db.workers.workerConfigured(1, 4013, [])
yield self.master.db.insert_test_data([
fakedb.ConnectedWorker(id=114, masterid=13, workerid=1),
])
yield self.setupSomeBuilds()
self.master.db.builds.finishBuild(buildid=13, results=FAILURE)
self.master.db.builds.finishBuild(buildid=15, results=SUCCESS)
self.master.db.builds.finishBuild(buildid=16, results=FAILURE)
yield self.do_test_command('status')
@defer.inlineCallbacks
def test_command_status_all(self):
yield self.do_test_command('status', args='all')
@defer.inlineCallbacks
def test_command_status_builder0_offline(self):
yield self.do_test_command('status', args=self.BUILDER_NAMES[0])
self.assertEqual(self.sent, [f'`{self.BUILDER_NAMES[0]}`: offline'])
@defer.inlineCallbacks
def test_command_status_builder0_running(self):
yield self.setupSomeBuilds()
yield self.do_test_command('status', args=self.BUILDER_NAMES[0])
self.assertEqual(len(self.sent), 1)
self.assertIn('`builder1`: running', self.sent[0])
self.assertRegex(self.sent[0], r' build \[#3\].* \(no current step\)')
self.assertRegex(self.sent[0], r' build \[#6\].* \(no current step\)')
@defer.inlineCallbacks
def test_command_status_bogus(self):
yield self.do_test_command('status', args='bogus_builder', exp_UsageError=True)
def sub_seconds(self, strings):
# sometimes timing works out wrong, so just call it "n seconds"
return [re.sub(r'\d seconds|a moment', 'N seconds', s) for s in strings]
@defer.inlineCallbacks
def test_command_last(self):
yield self.setupSomeBuilds()
yield self.setup_multi_builders()
# Also set the connectedness:
yield self.master.db.insert_test_data([
fakedb.ConnectedWorker(id=113, masterid=13, workerid=2)
])
yield self.do_test_command('last')
self.assertEqual(len(self.sent), 1)
sent = self.sub_seconds(self.sent)
self.assertIn('`builder1`: last build completed successfully (N seconds ago)', sent)
@defer.inlineCallbacks
def test_command_last_all(self):
yield self.setupSomeBuilds()
yield self.do_test_command('last', args='all')
self.assertEqual(len(self.sent), 1)
sent = self.sub_seconds(self.sent)
self.assertIn('`builder1`: last build completed successfully (N seconds ago)', sent[0])
self.assertIn('`builder2`: no builds run since last restart', sent[0])
@defer.inlineCallbacks
def test_command_last_builder_bogus(self):
yield self.do_test_command('last', args="BOGUS", exp_UsageError=True)
@defer.inlineCallbacks
def test_command_last_builder0(self):
yield self.setupSomeBuilds()
yield self.do_test_command('last', args=self.BUILDER_NAMES[0])
self.assertEqual(len(self.sent), 1)
sent = self.sub_seconds(self.sent)
self.assertIn('`builder1`: last build completed successfully (N seconds ago)', sent)
@defer.inlineCallbacks
def test_command_last_builder1(self):
yield self.setupSomeBuilds()
yield self.do_test_command('last', args=self.BUILDER_NAMES[1])
self.assertEqual(len(self.sent), 1)
self.assertIn('`builder2`: no builds run since last restart', self.sent)
@defer.inlineCallbacks
def test_command_watch(self):
yield self.do_test_command('watch', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_watch_builder0_no_builds(self):
yield self.do_test_command('watch', args=self.BUILDER_NAMES[0])
self.assertEqual(len(self.sent), 1)
self.assertIn('There are no currently running builds.', self.sent[0])
@defer.inlineCallbacks
def test_command_watch_builder0(self):
yield self.setupSomeBuilds()
yield self.do_test_command('watch', args=self.BUILDER_NAMES[0])
self.assertEqual(len(self.sent), 2)
self.assertIn(
'Watching build [#3](http://localhost:8080/#/builders/23/builds/3) of '
'`builder1` until it finishes...',
self.sent,
)
self.assertIn(
'Watching build [#6](http://localhost:8080/#/builders/23/builds/6) of '
'`builder1` until it finishes...',
self.sent,
)
@defer.inlineCallbacks
def test_command_watch_builder0_get_notifications(self):
# (continue from the prior test)
self.bot.tags = None
yield self.test_command_watch_builder0()
del self.sent[:]
yield self.sendBuildFinishedMessage(16)
self.assertEqual(len(self.sent), 1)
self.assertIn(
"Build [#6](http://localhost:8080/#/builders/23/builds/6) of "
"`builder1` completed successfully.",
self.sent,
)
@defer.inlineCallbacks
def test_command_watch_builder1(self):
yield self.setupSomeBuilds()
yield self.do_test_command('watch', args=self.BUILDER_NAMES[0])
self.assertEqual(len(self.sent), 2)
self.assertIn(
'Watching build [#3](http://localhost:8080/#/builders/23/builds/3) of '
'`builder1` until it finishes...',
self.sent,
)
self.assertIn(
'Watching build [#6](http://localhost:8080/#/builders/23/builds/6) of '
'`builder1` until it finishes...',
self.sent,
)
@defer.inlineCallbacks
def sendBuildFinishedMessage(self, buildid, results=0):
self.master.db.builds.finishBuild(buildid=buildid, results=SUCCESS)
build = yield self.master.data.get(('builds', buildid))
self.master.mq.callConsumer(
('builds', str(buildid), 'complete'),
{
"buildid": buildid,
"number": build['number'],
"builderid": build['builderid'],
"buildrequestid": build['buildrequestid'],
"workerid": build['workerid'],
"masterid": build['masterid'],
"started_at": datetime2epoch(build['started_at']),
"complete": True,
"complete_at": datetime2epoch(build['complete_at']),
"state_string": '',
"results": results,
},
)
@defer.inlineCallbacks
def test_command_stop(self):
yield self.do_test_command('stop', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_stop_bogus_builder(self):
yield self.do_test_command(
'stop', args="build BOGUS 'i have a reason'", exp_UsageError=True
)
@defer.inlineCallbacks
def test_command_stop_builder0_no_builds(self):
yield self.do_test_command('stop', args=f"build {self.BUILDER_NAMES[0]} 'i have a reason'")
self.assertEqual(len(self.sent), 1)
self.assertIn('no build is', self.sent[0])
@defer.inlineCallbacks
def test_command_stop_builder0_1_builds(self):
yield self.setupSomeBuilds()
yield self.do_test_command('stop', args=f"build {self.BUILDER_NAMES[0]} 'i have a reason'")
self.assertEqual(len(self.sent), 2)
self.assertRegex(self.sent[0], r'Build \[#[36]\].* of `builder1` interrupted')
self.assertRegex(self.sent[1], r'Build \[#[63]\].* of `builder1` interrupted')
@defer.inlineCallbacks
def test_command_force_no_args(self):
yield self.do_test_command('force', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_force_wrong_first_arg(self):
yield self.do_test_command('force', args='notbuild', exp_UsageError=True)
@defer.inlineCallbacks
def test_command_force_build_no_args(self):
yield self.do_test_command('force', args='build', exp_UsageError=True)
# TODO: missing tests for:
# - bad args
# - arg validation failure (self.master.config.validation)
@defer.inlineCallbacks
def test_command_force(self):
yield self.do_test_command(
'force',
args=(
'build --branch BRANCH1 --revision REV1 --props=PROP1=VALUE1 '
f'{self.BUILDER_NAMES[0]} REASON'
),
)
@defer.inlineCallbacks
def test_handleMessage_short_command(self):
self.contact.command_TESTY = mock.Mock()
yield self.contact.handleMessage('testy')
self.contact.command_TESTY.assert_called_with('')
@defer.inlineCallbacks
def test_handleMessage_long_command(self):
self.contact.command_TESTY = mock.Mock()
yield self.contact.handleMessage('testy westy boo')
self.contact.command_TESTY.assert_called_with('westy boo')
@defer.inlineCallbacks
def test_handleMessage_excited(self):
self.patch_send()
yield self.contact.handleMessage('hi!')
self.assertEqual(len(self.sent), 1) # who cares what it says..
@defer.inlineCallbacks
def test_handleMessage_exception(self):
self.patch_send()
def command_TESTY(msg):
raise RuntimeError("FAIL")
self.contact.command_TESTY = command_TESTY
yield self.contact.handleMessage('testy boom')
self.assertEqual(self.sent, ["Something bad happened (see logs)"])
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
@defer.inlineCallbacks
def test_handleMessage_UsageError(self):
self.patch_send()
def command_TESTY(msg):
raise words.UsageError("oh noes")
self.contact.command_TESTY = command_TESTY
yield self.contact.handleMessage('testy boom')
self.assertEqual(self.sent, ["oh noes"])
@defer.inlineCallbacks
def test_unclosed_quote(self):
yield self.do_test_command('list', args='args\'', exp_UsageError=True)
yield self.do_test_command('status', args='args\'', exp_UsageError=True)
yield self.do_test_command('notify', args='args\'', exp_UsageError=True)
yield self.do_test_command('watch', args='args\'', exp_UsageError=True)
yield self.do_test_command('force', args='args\'', exp_UsageError=True)
yield self.do_test_command('stop', args='args\'', exp_UsageError=True)
yield self.do_test_command('last', args='args\'', exp_UsageError=True)
yield self.do_test_command('help', args='args\'', exp_UsageError=True)
@defer.inlineCallbacks
def test_buildStarted(self):
yield self.setupSomeBuilds()
self.patch_send()
build = yield self.master.data.get(('builds', 13))
self.bot.tags = None
self.contact.channel.notify_for = lambda _: True
self.contact.useRevisions = False
self.contact.channel.buildStarted(build)
self.assertEqual(
self.sent.pop(),
"Build [#3](http://localhost:8080/#/builders/23/builds/3) of `builder1` started.",
)
def test_getCommandMethod_authz_default(self):
self.bot.authz = words.StatusBot.expand_authz(None)
meth = self.contact.getCommandMethod('shutdown')
self.assertEqual(meth, self.contact.access_denied)
authz1 = {
'force': ['me'],
'shutdown': ['notme', 'someone'],
('dance', 'notify'): True,
'': False,
}
def test_getCommandMethod_explicit_allow(self):
self.bot.authz = words.StatusBot.expand_authz(self.authz1)
meth = self.contact.getCommandMethod('force')
self.assertNotEqual(meth, self.contact.access_denied)
def test_getCommandMethod_explicit_disallow(self):
self.bot.authz = words.StatusBot.expand_authz(self.authz1)
meth = self.contact.getCommandMethod('shutdown')
self.assertEqual(meth, self.contact.access_denied)
def test_getCommandMethod_explicit_multi(self):
self.bot.authz = words.StatusBot.expand_authz(self.authz1)
self.assertIn('DANCE', self.bot.authz)
meth = self.contact.getCommandMethod('dance')
self.assertNotEqual(meth, self.contact.access_denied)
def test_getCommandMethod_explicit_default(self):
self.bot.authz = words.StatusBot.expand_authz(self.authz1)
meth = self.contact.getCommandMethod('help')
self.assertEqual(meth, self.contact.access_denied)
authz2 = {'shutdown': False, '': False, '*': True}
def test_getCommandMethod_exclamation(self):
self.bot.authz = words.StatusBot.expand_authz(self.authz2)
meth = self.contact.getCommandMethod('help')
self.assertNotEqual(meth, self.contact.access_denied)
def test_getCommandMethod_exclamation_override(self):
self.bot.authz = words.StatusBot.expand_authz(self.authz2)
meth = self.contact.getCommandMethod('shutdown')
self.assertEqual(meth, self.contact.access_denied)
def test_access_denied(self):
self.patch_send()
self.contact.access_denied()
self.assertIn("not pass", self.sent[0])
@defer.inlineCallbacks
def test_bot_loadState(self):
boid = yield self.bot._get_object_id()
yield self.master.db.insert_test_data([
fakedb.ObjectState(
objectid=boid, name='notify_events', value_json='[["#channel1", ["warnings"]]]'
),
])
yield self.bot.loadState()
self.assertEqual(self.bot.channels['#channel1'].notify_events, {'warnings'})
| 31,233 | Python | .py | 671 | 37.779434 | 100 | 0.652757 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,457 | test_generators_utils.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_generators_utils.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import copy
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.results import CANCELLED
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.reporters import utils
from buildbot.reporters.generators.utils import BuildStatusGeneratorMixin
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.reporter import ReporterTestMixin
class TestBuildGenerator(ConfigErrorsMixin, TestReactorMixin, unittest.TestCase, ReporterTestMixin):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def insert_build_finished_get_props(self, results, **kwargs):
build = yield self.insert_build_finished(results, **kwargs)
yield utils.getDetailsForBuild(self.master, build, want_properties=True)
return build
def create_generator(
self,
mode=("failing", "passing", "warnings"),
tags=None,
builders=None,
schedulers=None,
branches=None,
subject="Some subject",
add_logs=None,
add_patch=False,
):
return BuildStatusGeneratorMixin(
mode, tags, builders, schedulers, branches, subject, add_logs, add_patch
)
def test_generate_name(self):
g = self.create_generator(
tags=['tag1', 'tag2'],
builders=['b1', 'b2'],
schedulers=['s1', 's2'],
branches=['b1', 'b2'],
)
self.assertEqual(
g.generate_name(),
'BuildStatusGeneratorMixin_tags_tag1+tag2_builders_b1+b2_'
+ 'schedulers_s1+s2_branches_b1+b2failing_passing_warnings',
)
@parameterized.expand([
('tags', 'tag'),
('tags', 1),
('builders', 'builder'),
('builders', 1),
('schedulers', 'scheduler'),
('schedulers', 1),
('branches', 'branch'),
('branches', 1),
])
def test_list_params_check_raises(self, arg_name, arg_value):
kwargs = {arg_name: arg_value}
g = self.create_generator(**kwargs)
with self.assertRaisesConfigError('must be a list or None'):
g.check()
@parameterized.expand([
('unknown_str', 'unknown', 'not a valid mode'),
('unknown_list', ['unknown'], 'not a valid mode'),
('unknown_list_two', ['unknown', 'failing'], 'not a valid mode'),
('all_in_list', ['all', 'failing'], 'must be passed in as a separate string'),
])
def test_tag_check_raises(self, name, mode, expected_exception):
g = self.create_generator(mode=mode)
with self.assertRaisesConfigError(expected_exception):
g.check()
def test_subject_newlines_not_allowed(self):
g = self.create_generator(subject='subject\nwith\nnewline')
with self.assertRaisesConfigError('Newlines are not allowed'):
g.check()
@defer.inlineCallbacks
def test_is_message_needed_ignores_unspecified_tags(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
# force tags
build['builder']['tags'] = ['slow']
g = self.create_generator(tags=["fast"])
self.assertFalse(g.is_message_needed_by_props(build))
@defer.inlineCallbacks
def test_is_message_needed_tags(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
# force tags
build['builder']['tags'] = ['fast']
g = self.create_generator(tags=["fast"])
self.assertTrue(g.is_message_needed_by_props(build))
@defer.inlineCallbacks
def test_is_message_needed_schedulers_sends_mail(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
g = self.create_generator(schedulers=['checkin'])
self.assertTrue(g.is_message_needed_by_props(build))
@defer.inlineCallbacks
def test_is_message_needed_schedulers_doesnt_send_mail(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
g = self.create_generator(schedulers=['some-random-scheduler'])
self.assertFalse(g.is_message_needed_by_props(build))
@defer.inlineCallbacks
def test_is_message_needed_branches_sends_mail(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
g = self.create_generator(branches=['refs/pull/34/merge'])
self.assertTrue(g.is_message_needed_by_props(build))
@defer.inlineCallbacks
def test_is_message_needed_branches_doesnt_send_mail(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
g = self.create_generator(branches=['some-random-branch'])
self.assertFalse(g.is_message_needed_by_props(build))
@defer.inlineCallbacks
def run_simple_test_sends_message_for_mode(self, mode, result, should_send=True):
build = yield self.insert_build_finished_get_props(result)
g = self.create_generator(mode=mode)
self.assertEqual(g.is_message_needed_by_results(build), should_send)
def run_simple_test_ignores_message_for_mode(self, mode, result):
return self.run_simple_test_sends_message_for_mode(mode, result, False)
def test_is_message_needed_mode_all_for_success(self):
return self.run_simple_test_sends_message_for_mode("all", SUCCESS)
def test_is_message_needed_mode_all_for_failure(self):
return self.run_simple_test_sends_message_for_mode("all", FAILURE)
def test_is_message_needed_mode_all_for_warnings(self):
return self.run_simple_test_sends_message_for_mode("all", WARNINGS)
def test_is_message_needed_mode_all_for_exception(self):
return self.run_simple_test_sends_message_for_mode("all", EXCEPTION)
def test_is_message_needed_mode_all_for_cancelled(self):
return self.run_simple_test_sends_message_for_mode("all", CANCELLED)
def test_is_message_needed_mode_failing_for_success(self):
return self.run_simple_test_ignores_message_for_mode("failing", SUCCESS)
def test_is_message_needed_mode_failing_for_failure(self):
return self.run_simple_test_sends_message_for_mode("failing", FAILURE)
def test_is_message_needed_mode_failing_for_warnings(self):
return self.run_simple_test_ignores_message_for_mode("failing", WARNINGS)
def test_is_message_needed_mode_failing_for_exception(self):
return self.run_simple_test_ignores_message_for_mode("failing", EXCEPTION)
def test_is_message_needed_mode_exception_for_success(self):
return self.run_simple_test_ignores_message_for_mode("exception", SUCCESS)
def test_is_message_needed_mode_exception_for_failure(self):
return self.run_simple_test_ignores_message_for_mode("exception", FAILURE)
def test_is_message_needed_mode_exception_for_warnings(self):
return self.run_simple_test_ignores_message_for_mode("exception", WARNINGS)
def test_is_message_needed_mode_exception_for_exception(self):
return self.run_simple_test_sends_message_for_mode("exception", EXCEPTION)
def test_is_message_needed_mode_warnings_for_success(self):
return self.run_simple_test_ignores_message_for_mode("warnings", SUCCESS)
def test_is_message_needed_mode_warnings_for_failure(self):
return self.run_simple_test_sends_message_for_mode("warnings", FAILURE)
def test_is_message_needed_mode_warnings_for_warnings(self):
return self.run_simple_test_sends_message_for_mode("warnings", WARNINGS)
def test_is_message_needed_mode_warnings_for_exception(self):
return self.run_simple_test_ignores_message_for_mode("warnings", EXCEPTION)
def test_is_message_needed_mode_passing_for_success(self):
return self.run_simple_test_sends_message_for_mode("passing", SUCCESS)
def test_is_message_needed_mode_passing_for_failure(self):
return self.run_simple_test_ignores_message_for_mode("passing", FAILURE)
def test_is_message_needed_mode_passing_for_warnings(self):
return self.run_simple_test_ignores_message_for_mode("passing", WARNINGS)
def test_is_message_needed_mode_passing_for_exception(self):
return self.run_simple_test_ignores_message_for_mode("passing", EXCEPTION)
@defer.inlineCallbacks
def run_sends_message_for_problems(self, mode, results1, results2, should_send=True):
build = yield self.insert_build_finished_get_props(results2)
g = self.create_generator(mode=mode)
if results1 is not None:
build['prev_build'] = copy.deepcopy(build)
build['prev_build']['results'] = results1
else:
build['prev_build'] = None
self.assertEqual(g.is_message_needed_by_results(build), should_send)
def test_is_message_needed_mode_problem_sends_on_problem(self):
return self.run_sends_message_for_problems("problem", SUCCESS, FAILURE, True)
def test_is_message_needed_mode_problem_ignores_successful_build(self):
return self.run_sends_message_for_problems("problem", SUCCESS, SUCCESS, False)
def test_is_message_needed_mode_problem_ignores_two_failed_builds_in_sequence(self):
return self.run_sends_message_for_problems("problem", FAILURE, FAILURE, False)
def test_is_message_needed_mode_change_sends_on_change(self):
return self.run_sends_message_for_problems("change", FAILURE, SUCCESS, True)
def test_is_message_needed_mode_change_sends_on_failure(self):
return self.run_sends_message_for_problems("change", SUCCESS, FAILURE, True)
def test_is_message_needed_mode_change_ignores_first_build(self):
return self.run_sends_message_for_problems("change", None, FAILURE, False)
def test_is_message_needed_mode_change_ignores_first_build2(self):
return self.run_sends_message_for_problems("change", None, SUCCESS, False)
def test_is_message_needed_mode_change_ignores_same_result_in_sequence(self):
return self.run_sends_message_for_problems("change", SUCCESS, SUCCESS, False)
def test_is_message_needed_mode_change_ignores_same_result_in_sequence2(self):
return self.run_sends_message_for_problems("change", FAILURE, FAILURE, False)
@parameterized.expand([
('both_none', None, None, (None, False)),
('old_none', None, 'type', ('type', True)),
('new_none', 'type', None, ('type', False)),
('same', 'type', 'type', ('type', True)),
('different', 'type1', 'type2', ('type1', False)),
])
def test_merge_msgtype(self, name, old, new, expected_result):
g = self.create_generator()
self.assertEqual(g._merge_msgtype(old, new), expected_result)
@parameterized.expand([
('both_none', None, None, None),
('old_none', None, 'sub', 'sub'),
('new_none', 'sub', None, 'sub'),
('same', 'sub', 'sub', 'sub'),
('different', 'sub1', 'sub2', 'sub1'),
])
def test_merge_subject(self, name, old, new, expected_result):
g = self.create_generator()
self.assertEqual(g._merge_subject(old, new), expected_result)
@parameterized.expand([
('both_none', None, None, (None, True)),
('old_none', None, 'body', ('body', True)),
('new_none', 'body', None, ('body', True)),
('both_str', 'body1\n', 'body2\n', ('body1\nbody2\n', True)),
('both_list', ['body1'], ['body2'], (['body1', 'body2'], True)),
('both_dict', {'v': 'body1'}, {'v': 'body2'}, ({'v': 'body1'}, False)),
('str_list', ['body1'], 'body2', (['body1'], False)),
])
def test_merge_body(self, name, old, new, expected_result):
g = self.create_generator()
self.assertEqual(g._merge_body(old, new), expected_result)
@parameterized.expand([
("both_none", None, None, (None, True)),
("old_none", None, {"k": "v"}, ({"k": "v"}, True)),
("new_none", {"k": "v"}, None, ({"k": "v"}, True)),
(
"both_same_key",
{"k": {"kk1": "vv1"}},
{"k": {"kk2": "vv2"}},
({"k": {"kk1": "vv1", "kk2": "vv2"}}, True),
),
(
"both_same_key_conflict",
{"k": {"kk1": "vv1"}},
{"k": {"kk1": "vv2"}},
({"k": {"kk1": "vv1"}}, True),
),
])
def test_merge_info(self, name, old, new, expected_result):
g = self.create_generator()
self.assertEqual(g._merge_extra_info(old, new), expected_result)
| 13,645 | Python | .py | 261 | 44.773946 | 100 | 0.672872 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,458 | test_bitbucketserver.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_bitbucketserver.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import datetime
from unittest.mock import Mock
from dateutil.tz import tzutc
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.plugins import util
from buildbot.process.builder import Builder
from buildbot.process.properties import Interpolate
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.reporters.bitbucketserver import HTTP_CREATED
from buildbot.reporters.bitbucketserver import HTTP_PROCESSED
from buildbot.reporters.bitbucketserver import BitbucketServerCoreAPIStatusPush
from buildbot.reporters.bitbucketserver import BitbucketServerPRCommentPush
from buildbot.reporters.bitbucketserver import BitbucketServerStatusPush
from buildbot.reporters.generators.build import BuildStartEndStatusGenerator
from buildbot.reporters.generators.build import BuildStatusGenerator
from buildbot.reporters.generators.buildset import BuildSetStatusGenerator
from buildbot.reporters.message import MessageFormatter
from buildbot.reporters.message import MessageFormatterRenderable
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.logging import LoggingMixin
from buildbot.test.util.reporter import ReporterTestMixin
HTTP_NOT_FOUND = 404
class TestException(Exception):
pass
class TestBitbucketServerStatusPush(
TestReactorMixin, ConfigErrorsMixin, unittest.TestCase, ReporterTestMixin, LoggingMixin
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
yield self.master.startService()
@defer.inlineCallbacks
def setupReporter(self, **kwargs):
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master, self, 'serv', auth=('username', 'passwd'), debug=None, verify=None
)
self.sp = BitbucketServerStatusPush(
"serv", Interpolate("username"), Interpolate("passwd"), **kwargs
)
yield self.sp.setServiceParent(self.master)
@defer.inlineCallbacks
def tearDown(self):
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def _check_start_and_finish_build(self, build):
self._http.expect(
'post',
'/rest/build-status/1.0/commits/d34db33fd43db33f',
json={
'url': 'http://localhost:8080/#/builders/79/builds/0',
'state': 'INPROGRESS',
'key': 'Builder0',
'description': 'Build started.',
},
code=HTTP_PROCESSED,
)
self._http.expect(
'post',
'/rest/build-status/1.0/commits/d34db33fd43db33f',
json={
'url': 'http://localhost:8080/#/builders/79/builds/0',
'state': 'SUCCESSFUL',
'key': 'Builder0',
'description': 'Build done.',
},
code=HTTP_PROCESSED,
)
self._http.expect(
'post',
'/rest/build-status/1.0/commits/d34db33fd43db33f',
json={
'url': 'http://localhost:8080/#/builders/79/builds/0',
'state': 'FAILED',
'key': 'Builder0',
'description': 'Build done.',
},
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_basic(self):
self.setupReporter()
build = yield self.insert_build_finished(SUCCESS)
yield self._check_start_and_finish_build(build)
@defer.inlineCallbacks
def test_setting_options(self):
generator = BuildStartEndStatusGenerator(
start_formatter=MessageFormatterRenderable('Build started.'),
end_formatter=MessageFormatterRenderable('Build finished.'),
)
self.setupReporter(statusName='Build', generators=[generator])
build = yield self.insert_build_finished(SUCCESS)
self._http.expect(
'post',
'/rest/build-status/1.0/commits/d34db33fd43db33f',
json={
'url': 'http://localhost:8080/#/builders/79/builds/0',
'state': 'INPROGRESS',
'key': 'Builder0',
'name': 'Build',
'description': 'Build started.',
},
code=HTTP_PROCESSED,
)
self._http.expect(
'post',
'/rest/build-status/1.0/commits/d34db33fd43db33f',
json={
'url': 'http://localhost:8080/#/builders/79/builds/0',
'state': 'SUCCESSFUL',
'key': 'Builder0',
'name': 'Build',
'description': 'Build finished.',
},
code=HTTP_PROCESSED,
)
self._http.expect(
'post',
'/rest/build-status/1.0/commits/d34db33fd43db33f',
json={
'url': 'http://localhost:8080/#/builders/79/builds/0',
'state': 'FAILED',
'key': 'Builder0',
'name': 'Build',
'description': 'Build finished.',
},
code=HTTP_PROCESSED,
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_error(self):
self.setupReporter()
build = yield self.insert_build_finished(SUCCESS)
self._http.expect(
'post',
'/rest/build-status/1.0/commits/d34db33fd43db33f',
json={
'url': 'http://localhost:8080/#/builders/79/builds/0',
'state': 'INPROGRESS',
'key': 'Builder0',
'description': 'Build started.',
},
code=HTTP_NOT_FOUND,
content_json={
"error_description": "This commit is unknown to us",
"error": "invalid_commit",
},
)
build['complete'] = False
self.setUpLogging()
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged('404: Unable to send Bitbucket Server status')
@defer.inlineCallbacks
def test_basic_with_no_revision(self):
yield self.setupReporter()
self.reporter_test_revision = None
build = yield self.insert_build_finished(SUCCESS)
self.setUpLogging()
# we don't expect any request
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged("Unable to get the commit hash")
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
class TestBitbucketServerCoreAPIStatusPush(
ConfigErrorsMixin, TestReactorMixin, unittest.TestCase, ReporterTestMixin, LoggingMixin
):
@defer.inlineCallbacks
def setupReporter(self, token=None, **kwargs):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
def setup_properties(props):
props.setProperty("buildername", "Builder0", "Builder")
return defer.succeed(None)
builder = Mock(spec=Builder)
builder.master = self.master
builder.name = "Builder0"
builder.setup_properties = setup_properties
self.master.botmaster.getBuilderById = Mock(return_value=builder)
http_headers = {} if token is None else {'Authorization': 'Bearer tokentoken'}
http_auth = ('username', 'passwd') if token is None else None
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master, self, 'serv', auth=http_auth, headers=http_headers, debug=None, verify=None
)
auth = (Interpolate("username"), Interpolate("passwd")) if token is None else None
self.sp = BitbucketServerCoreAPIStatusPush("serv", token=token, auth=auth, **kwargs)
yield self.sp.setServiceParent(self.master)
yield self.master.startService()
def setUp(self):
self.master = None
@defer.inlineCallbacks
def tearDown(self):
if self.master:
if self.master.running:
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def _check_start_and_finish_build(self, build, parentPlan=False, epoch=False):
_name = "Builder_parent #1 \u00bb Builder0 #0" if parentPlan else "Builder0 #0"
_parent = "Builder_parent" if parentPlan else "Builder0"
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': _name,
'description': 'Build started.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'refs/heads/master',
'buildNumber': '0',
'state': 'INPROGRESS',
'parent': _parent,
'duration': None,
'testResults': None,
},
code=HTTP_PROCESSED,
)
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': _name,
'description': 'Build done.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'refs/heads/master',
'buildNumber': '0',
'state': 'SUCCESSFUL',
'parent': _parent,
'duration': 10000,
'testResults': None,
},
code=HTTP_PROCESSED,
)
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': _name,
'description': 'Build done.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'refs/heads/master',
'buildNumber': '0',
'state': 'FAILED',
'parent': _parent,
'duration': 10000,
'testResults': None,
},
code=HTTP_PROCESSED,
)
if epoch:
build['started_at'] = 1554161913
else:
build['started_at'] = datetime.datetime(2019, 4, 1, 23, 38, 33, 154354, tzinfo=tzutc())
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
if epoch:
build["complete_at"] = 1554161923
else:
build["complete_at"] = datetime.datetime(2019, 4, 1, 23, 38, 43, 154354, tzinfo=tzutc())
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_buildrequest(self):
yield self.setupReporter()
buildrequest = yield self.insert_buildrequest_new()
_name = "Builder0 #(build request)"
_parent = "Builder0"
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': _name,
'description': 'Build pending.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/buildrequests/11',
'ref': 'refs/heads/master',
'buildNumber': '',
'state': 'INPROGRESS',
'parent': _parent,
'duration': None,
'testResults': None,
},
code=HTTP_PROCESSED,
)
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': _name,
'description': 'Build pending.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/buildrequests/11',
'ref': 'refs/heads/master',
'buildNumber': '',
'state': 'FAILED',
'parent': _parent,
'duration': None,
'testResults': None,
},
code=HTTP_PROCESSED,
)
yield self.sp._got_event(('buildrequests', 11, 'new'), buildrequest)
yield self.sp._got_event(('buildrequests', 11, 'cancel'), buildrequest)
def test_config_no_base_url(self):
with self.assertRaisesConfigError("Parameter base_url has to be given"):
BitbucketServerCoreAPIStatusPush(base_url=None)
def test_config_auth_and_token_mutually_exclusive(self):
with self.assertRaisesConfigError(
"Only one authentication method can be given (token or auth)"
):
BitbucketServerCoreAPIStatusPush("serv", token="x", auth=("username", "passwd"))
@defer.inlineCallbacks
def test_basic(self):
yield self.setupReporter()
build = yield self.insert_build_finished(SUCCESS)
yield self._check_start_and_finish_build(build)
@defer.inlineCallbacks
def test_basic_epoch(self):
yield self.setupReporter()
build = yield self.insert_build_finished(SUCCESS)
yield self._check_start_and_finish_build(build, epoch=True)
@defer.inlineCallbacks
def test_with_parent(self):
yield self.setupReporter()
build = yield self.insert_build_finished(SUCCESS, parent_plan=True)
yield self._check_start_and_finish_build(build, parentPlan=True)
@defer.inlineCallbacks
def test_with_token(self):
yield self.setupReporter(token='tokentoken')
build = yield self.insert_build_finished(SUCCESS)
yield self._check_start_and_finish_build(build)
@defer.inlineCallbacks
def test_error_setup_status(self):
yield self.setupReporter()
@defer.inlineCallbacks
def raise_deferred_exception(**kwargs):
raise TestException()
self.sp.createStatus = Mock(side_effect=raise_deferred_exception)
build = yield self.insert_build_finished(SUCCESS)
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertEqual(len(self.flushLoggedErrors(TestException)), 1)
@defer.inlineCallbacks
def test_error(self):
self.setupReporter()
build = yield self.insert_build_finished(SUCCESS)
self.setUpLogging()
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': 'Builder0 #0',
'description': 'Build started.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'refs/heads/master',
'buildNumber': '0',
'state': 'INPROGRESS',
'parent': 'Builder0',
'duration': None,
'testResults': None,
},
code=HTTP_NOT_FOUND,
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged('404: Unable to send Bitbucket Server status')
@defer.inlineCallbacks
def test_with_full_ref(self):
yield self.setupReporter()
self.reporter_test_branch = "refs/heads/master"
build = yield self.insert_build_finished(SUCCESS)
yield self._check_start_and_finish_build(build)
@defer.inlineCallbacks
def test_with_no_ref(self):
yield self.setupReporter()
self.reporter_test_branch = None
build = yield self.insert_build_finished(SUCCESS)
self.setUpLogging()
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': 'Builder0 #0',
'description': 'Build started.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': None,
'buildNumber': '0',
'state': 'INPROGRESS',
'parent': 'Builder0',
'duration': None,
'testResults': None,
},
code=HTTP_PROCESSED,
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged("WARNING: Unable to resolve ref for SSID: 234.")
@defer.inlineCallbacks
def test_with_no_revision(self):
yield self.setupReporter()
self.reporter_test_revision = None
build = yield self.insert_build_finished(SUCCESS)
self.setUpLogging()
# we don't expect any request
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged("Unable to get the commit hash for SSID: 234")
@defer.inlineCallbacks
def test_with_no_repo(self):
yield self.setupReporter()
self.reporter_test_repo = ''
build = yield self.insert_build_finished(SUCCESS)
self.setUpLogging()
# we don't expect any request
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged("Unable to parse repository info from '' for SSID: 234")
@defer.inlineCallbacks
def test_with_renderers(self):
@util.renderer
def r_testresults(props):
return {
"failed": props.getProperty("unittests_failed", 0),
"skipped": props.getProperty("unittests_skipped", 0),
"successful": props.getProperty("unittests_successful", 0),
}
@util.renderer
def r_duration(props):
return props.getProperty("unittests_runtime")
yield self.setupReporter(
statusName=Interpolate("%(prop:plan_name)s"),
statusSuffix=Interpolate(" [%(prop:unittests_os)s]"),
buildNumber=Interpolate('100'),
ref=Interpolate("%(prop:branch)s"),
parentName=Interpolate("%(prop:master_plan)s"),
testResults=r_testresults,
duration=r_duration,
)
self.reporter_test_props['unittests_failed'] = 0
self.reporter_test_props['unittests_skipped'] = 2
self.reporter_test_props['unittests_successful'] = 3
self.reporter_test_props['unittests_runtime'] = 50000
self.reporter_test_props['unittests_os'] = "win10"
self.reporter_test_props['plan_name'] = "Unittests"
self.reporter_test_props['master_plan'] = "Unittests-master"
build = yield self.insert_build_finished(SUCCESS)
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': 'Unittests [win10]',
'description': 'Build done.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': "refs/pull/34/merge",
'buildNumber': '100',
'state': 'SUCCESSFUL',
'parent': 'Unittests-master',
'duration': 50000,
'testResults': {'failed': 0, 'skipped': 2, 'successful': 3},
},
code=HTTP_PROCESSED,
)
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_with_test_results(self):
yield self.setupReporter()
self.reporter_test_props['tests_skipped'] = 2
self.reporter_test_props['tests_successful'] = 3
build = yield self.insert_build_finished(SUCCESS)
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': 'Builder0 #0',
'description': 'Build done.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'refs/heads/master',
'buildNumber': '0',
'state': 'SUCCESSFUL',
'parent': 'Builder0',
'duration': 10000,
'testResults': {'failed': 0, 'skipped': 2, 'successful': 3},
},
code=HTTP_PROCESSED,
)
build['started_at'] = datetime.datetime(2019, 4, 1, 23, 38, 33, 154354, tzinfo=tzutc())
build["complete_at"] = datetime.datetime(2019, 4, 1, 23, 38, 43, 154354, tzinfo=tzutc())
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_verbose(self):
yield self.setupReporter(verbose=True)
build = yield self.insert_build_finished(SUCCESS)
self.setUpLogging()
self._http.expect(
'post',
'/rest/api/1.0/projects/example.org/repos/repo/commits/d34db33fd43db33f/builds',
json={
'name': 'Builder0 #0',
'description': 'Build started.',
'key': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': "refs/heads/master",
'buildNumber': '0',
'state': 'INPROGRESS',
'parent': 'Builder0',
'duration': None,
'testResults': None,
},
code=HTTP_PROCESSED,
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged('Sending payload:')
self.assertLogged('Status "INPROGRESS" sent for example.org/repo d34db33fd43db33f')
UNICODE_BODY = "body: \u00e5\u00e4\u00f6 text"
EXPECTED_API = '/rest/api/1.0/projects/PRO/repos/myrepo/pull-requests/20/comments'
PR_URL = "http://example.com/projects/PRO/repos/myrepo/pull-requests/20"
class TestBitbucketServerPRCommentPush(
TestReactorMixin, unittest.TestCase, ReporterTestMixin, LoggingMixin
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
yield self.master.startService()
@defer.inlineCallbacks
def setupReporter(self, verbose=True, generator_class=BuildStatusGenerator, **kwargs):
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master, self, 'serv', auth=('username', 'passwd'), debug=None, verify=None
)
formatter = Mock(spec=MessageFormatter)
formatter.format_message_for_build.return_value = {
"body": UNICODE_BODY,
"type": "text",
"subject": "subject",
"extra_info": None,
}
formatter.want_properties = True
formatter.want_steps = False
formatter.want_logs = False
formatter.want_logs_content = False
generator = generator_class(message_formatter=formatter)
self.cp = BitbucketServerPRCommentPush(
"serv",
Interpolate("username"),
Interpolate("passwd"),
verbose=verbose,
generators=[generator],
**kwargs,
)
yield self.cp.setServiceParent(self.master)
@defer.inlineCallbacks
def tearDown(self):
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setupBuildResults(self, buildResults, set_pr=True):
yield super().insert_test_data([buildResults], buildResults)
build = yield self.master.data.get(('builds', 20))
if set_pr:
yield self.master.db.builds.setBuildProperty(20, "pullrequesturl", PR_URL, "test")
return build
@defer.inlineCallbacks
def test_reporter_basic(self):
yield self.setupReporter()
build = yield self.setupBuildResults(SUCCESS)
self._http.expect("post", EXPECTED_API, json={"text": UNICODE_BODY}, code=HTTP_CREATED)
build["complete"] = True
self.setUpLogging()
yield self.cp._got_event(('builds', 20, 'finished'), build)
self.assertLogged(f'Comment sent to {PR_URL}')
@defer.inlineCallbacks
def test_reporter_basic_without_logging(self):
yield self.setupReporter(verbose=False)
build = yield self.setupBuildResults(SUCCESS)
self._http.expect("post", EXPECTED_API, json={"text": UNICODE_BODY}, code=HTTP_CREATED)
build["complete"] = True
self.setUpLogging()
yield self.cp._got_event(('builds', 20, 'finished'), build)
self.assertNotLogged(f'Comment sent to {PR_URL}')
@defer.inlineCallbacks
def test_reporter_without_pullrequest(self):
yield self.setupReporter()
build = yield self.setupBuildResults(SUCCESS, set_pr=False)
build["complete"] = True
# we don't expect any request
yield self.cp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_reporter_with_buildset(self):
yield self.setupReporter(generator_class=BuildSetStatusGenerator)
yield self.setupBuildResults(SUCCESS)
buildset = yield self.get_inserted_buildset()
self._http.expect("post", EXPECTED_API, json={"text": UNICODE_BODY}, code=HTTP_CREATED)
yield self.cp._got_event(("buildsets", 98, "complete"), buildset)
@defer.inlineCallbacks
def test_reporter_logs_error_code_and_content_on_invalid_return_code(self):
yield self.setupReporter()
build = yield self.setupBuildResults(SUCCESS)
http_error_code = 500
error_body = {"errors": [{"message": "A dataXXXbase error has occurred."}]}
self._http.expect(
"post",
EXPECTED_API,
json={"text": UNICODE_BODY},
code=http_error_code,
content_json=error_body,
)
self.setUpLogging()
build['complete'] = True
yield self.cp._got_event(('builds', 20, 'finished'), build)
self.assertLogged(f"^{http_error_code}: Unable to send a comment: ")
self.assertLogged("A dataXXXbase error has occurred")
@defer.inlineCallbacks
def test_reporter_logs_error_code_without_content_on_invalid_return_code(self):
yield self.setupReporter()
build = yield self.setupBuildResults(SUCCESS)
http_error_code = 503
self._http.expect("post", EXPECTED_API, json={"text": UNICODE_BODY}, code=http_error_code)
self.setUpLogging()
build['complete'] = True
yield self.cp._got_event(('builds', 20, 'finished'), build)
self.assertLogged(f"^{http_error_code}: Unable to send a comment: ")
@defer.inlineCallbacks
def test_reporter_does_not_log_return_code_on_valid_return_code(self):
yield self.setupReporter()
build = yield self.setupBuildResults(SUCCESS)
http_code = 201
self._http.expect("post", EXPECTED_API, json={"text": UNICODE_BODY}, code=http_code)
self.setUpLogging()
build['complete'] = True
yield self.cp._got_event(('builds', 20, 'finished'), build)
self.assertNotLogged(f"^{http_code}:")
| 29,399 | Python | .py | 676 | 33.044379 | 100 | 0.602486 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,459 | test_generators_build.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_generators_build.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest.mock import Mock
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.results import SUCCESS
from buildbot.reporters import utils
from buildbot.reporters.generators.build import BuildStartEndStatusGenerator
from buildbot.reporters.generators.build import BuildStatusGenerator
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.reporter import ReporterTestMixin
from buildbot.test.util.warnings import assertProducesWarnings
from buildbot.warnings import DeprecatedApiWarning
class TestBuildGenerator(ConfigErrorsMixin, TestReactorMixin, unittest.TestCase, ReporterTestMixin):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def insert_build_finished_get_props(
self, results, add_logs=None, want_logs_content=False, **kwargs
):
build = yield self.insert_build_finished(results, **kwargs)
yield utils.getDetailsForBuild(
self.master,
build,
want_properties=True,
add_logs=add_logs,
want_logs_content=want_logs_content,
)
return build
@defer.inlineCallbacks
def setup_generator(
self,
results=SUCCESS,
message=None,
db_args=None,
add_logs=None,
want_logs_content=False,
**kwargs,
):
if message is None:
message = {
"body": "body",
"type": "text",
"subject": "subject",
"extra_info": None,
}
if db_args is None:
db_args = {}
build = yield self.insert_build_finished_get_props(
results, want_logs_content=want_logs_content, add_logs=add_logs, **db_args
)
buildset = yield self.get_inserted_buildset()
g = BuildStatusGenerator(add_logs=add_logs, **kwargs)
g.formatter = Mock(spec=g.formatter)
g.formatter.want_logs_content = want_logs_content
g.formatter.format_message_for_build.return_value = message
return g, build, buildset
@defer.inlineCallbacks
def build_message(self, g, build, results=SUCCESS):
reporter = Mock()
reporter.getResponsibleUsersForBuild.return_value = []
report = yield g.build_message(g.formatter, self.master, reporter, build)
return report
@defer.inlineCallbacks
def generate(self, g, key, build):
reporter = Mock()
reporter.getResponsibleUsersForBuild.return_value = []
report = yield g.generate(self.master, reporter, key, build)
return report
@defer.inlineCallbacks
def test_build_message_nominal(self):
g, build, buildset = yield self.setup_generator(mode=("change",))
report = yield self.build_message(g, build)
g.formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=False, mode=('change',), users=[]
)
self.assertEqual(
report,
{
'body': 'body',
'subject': 'subject',
'type': 'text',
"extra_info": None,
'results': SUCCESS,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_build_message_no_result(self):
g, build, buildset = yield self.setup_generator(results=None, mode=("change",))
report = yield self.build_message(g, build, results=None)
g.formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=False, mode=('change',), users=[]
)
self.assertEqual(
report,
{
'body': 'body',
'subject': 'subject',
'type': 'text',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_build_message_no_result_formatter_no_subject(self):
message = {
"body": "body",
"type": "text",
"subject": None, # deprecated unspecified subject
"extra_info": None,
}
g, build, buildset = yield self.setup_generator(
results=None, message=message, mode=("change",)
)
report = yield self.build_message(g, build, results=None)
g.formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=False, mode=('change',), users=[]
)
self.assertEqual(
report,
{
'body': 'body',
'subject': 'Buildbot not finished in Buildbot on Builder0',
'type': 'text',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_build_message_addLogs(self):
with assertProducesWarnings(
DeprecatedApiWarning,
message_pattern=".*argument add_logs have been deprecated.*",
):
g, build, _ = yield self.setup_generator(mode=("change",), add_logs=True)
report = yield self.build_message(g, build)
self.assertEqual(report['logs'][0]['logid'], 60)
self.assertIn("log with", report['logs'][0]['content']['content'])
@defer.inlineCallbacks
def test_build_message_want_logs_content(self):
g, build, _ = yield self.setup_generator(mode=("change",), want_logs_content=True)
report = yield self.build_message(g, build)
self.assertEqual(report['logs'][0]['logid'], 60)
self.assertIn("log with", report['logs'][0]['content']['content'])
@defer.inlineCallbacks
def test_build_message_add_patch(self):
g, build, _ = yield self.setup_generator(
mode=("change",), add_patch=True, db_args={"insert_patch": True}
)
report = yield self.build_message(g, build)
patch_dict = {
'author': 'him@foo',
'body': b'hello, world',
'comment': 'foo',
'level': 3,
'patchid': 99,
'subdir': '/foo',
}
self.assertEqual(report['patches'], [patch_dict])
@defer.inlineCallbacks
def test_build_message_add_patch_no_patch(self):
g, build, _ = yield self.setup_generator(
mode=("change",), add_patch=True, db_args={'insert_patch': False}
)
report = yield self.build_message(g, build)
self.assertEqual(report['patches'], [])
@defer.inlineCallbacks
def test_generate_finished(self):
g, build, buildset = yield self.setup_generator()
report = yield self.generate(g, ('builds', 123, 'finished'), build)
self.assertEqual(
report,
{
'body': 'body',
'subject': 'subject',
'type': 'text',
"extra_info": None,
'results': SUCCESS,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_generate_finished_non_matching_builder(self):
g, build, _ = yield self.setup_generator(builders=['non-matched'])
report = yield self.generate(g, ('builds', 123, 'finished'), build)
self.assertIsNone(report)
@defer.inlineCallbacks
def test_generate_finished_non_matching_result(self):
g, build, _ = yield self.setup_generator(mode=('failing',))
report = yield self.generate(g, ('builds', 123, 'finished'), build)
self.assertIsNone(report)
@defer.inlineCallbacks
def test_generate_new(self):
g, build, buildset = yield self.setup_generator(
results=None, mode=("failing",), report_new=True
)
report = yield self.generate(g, ('builds', 123, 'new'), build)
self.assertEqual(
report,
{
'body': 'body',
'subject': 'subject',
'type': 'text',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
class TestBuildStartEndGenerator(
ConfigErrorsMixin, TestReactorMixin, unittest.TestCase, ReporterTestMixin
):
all_messages = ('failing', 'passing', 'warnings', 'exception', 'cancelled')
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def insert_build_finished_get_props(
self, results, add_logs=None, want_logs_content=False, **kwargs
):
build = yield self.insert_build_finished(results, **kwargs)
yield utils.getDetailsForBuild(
self.master,
build,
want_properties=True,
add_logs=add_logs,
want_logs_content=want_logs_content,
)
return build
@parameterized.expand([
('tags', 'tag'),
('tags', 1),
('builders', 'builder'),
('builders', 1),
('schedulers', 'scheduler'),
('schedulers', 1),
('branches', 'branch'),
('branches', 1),
])
def test_list_params_check_raises(self, arg_name, arg_value):
kwargs = {arg_name: arg_value}
g = BuildStartEndStatusGenerator(**kwargs)
with self.assertRaisesConfigError('must be a list or None'):
g.check()
def setup_generator(
self,
results=SUCCESS,
start_message=None,
end_message=None,
want_logs_content=False,
**kwargs,
):
if start_message is None:
start_message = {
"body": "start body",
"type": "plain",
"subject": "start subject",
"extra_info": None,
}
if end_message is None:
end_message = {
"body": "end body",
"type": "plain",
"subject": "end subject",
"extra_info": None,
}
g = BuildStartEndStatusGenerator(**kwargs)
g.start_formatter = Mock(spec=g.start_formatter)
g.start_formatter.want_logs_content = want_logs_content
g.start_formatter.format_message_for_build.return_value = start_message
g.end_formatter = Mock(spec=g.end_formatter)
g.end_formatter.want_logs_content = want_logs_content
g.end_formatter.format_message_for_build.return_value = end_message
return g
@defer.inlineCallbacks
def build_message(self, g, build, results=SUCCESS):
reporter = Mock()
reporter.getResponsibleUsersForBuild.return_value = []
report = yield g.build_message(g.start_formatter, self.master, reporter, build)
return report
@defer.inlineCallbacks
def generate(self, g, key, build):
reporter = Mock()
reporter.getResponsibleUsersForBuild.return_value = []
report = yield g.generate(self.master, reporter, key, build)
return report
@defer.inlineCallbacks
def test_build_message_start(self):
g = yield self.setup_generator()
build = yield self.insert_build_finished_get_props(SUCCESS)
buildset = yield self.get_inserted_buildset()
report = yield self.build_message(g, build)
g.start_formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=False, mode=self.all_messages, users=[]
)
self.assertEqual(
report,
{
'body': 'start body',
'subject': 'start subject',
'type': 'plain',
"extra_info": None,
'results': SUCCESS,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_build_message_start_no_result(self):
g = yield self.setup_generator(results=None)
build = yield self.insert_build_new()
buildset = yield self.get_inserted_buildset()
build["buildset"] = buildset
report = yield self.build_message(g, build, results=None)
g.start_formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=False, mode=self.all_messages, users=[]
)
self.assertEqual(
report,
{
'body': 'start body',
'subject': 'start subject',
'type': 'plain',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_is_message_needed_ignores_unspecified_tags(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
# force tags
build['builder']['tags'] = ['tag']
g = BuildStartEndStatusGenerator(tags=['not_existing_tag'])
self.assertFalse(g.is_message_needed_by_props(build))
@defer.inlineCallbacks
def test_is_message_needed_tags(self):
build = yield self.insert_build_finished_get_props(SUCCESS)
# force tags
build['builder']['tags'] = ['tag']
g = BuildStartEndStatusGenerator(tags=['tag'])
self.assertTrue(g.is_message_needed_by_props(build))
@defer.inlineCallbacks
def test_build_message_add_logs(self):
with assertProducesWarnings(
DeprecatedApiWarning,
message_pattern=".*argument add_logs have been deprecated.*",
):
g = yield self.setup_generator(add_logs=True)
build = yield self.insert_build_finished_get_props(SUCCESS, add_logs=True)
report = yield self.build_message(g, build)
self.assertEqual(report['logs'][0]['logid'], 60)
self.assertIn("log with", report['logs'][0]['content']['content'])
@defer.inlineCallbacks
def test_build_message_want_logs_content(self):
g = yield self.setup_generator(want_logs_content=True)
build = yield self.insert_build_finished_get_props(SUCCESS, want_logs_content=True)
report = yield self.build_message(g, build)
self.assertEqual(report['logs'][0]['logid'], 60)
self.assertIn("log with", report['logs'][0]['content']['content'])
@defer.inlineCallbacks
def test_build_message_add_patch(self):
g = yield self.setup_generator(add_patch=True)
build = yield self.insert_build_finished_get_props(SUCCESS, insert_patch=True)
report = yield self.build_message(g, build)
patch_dict = {
'author': 'him@foo',
'body': b'hello, world',
'comment': 'foo',
'level': 3,
'patchid': 99,
'subdir': '/foo',
}
self.assertEqual(report['patches'], [patch_dict])
@defer.inlineCallbacks
def test_build_message_add_patch_no_patch(self):
g = yield self.setup_generator(add_patch=True)
build = yield self.insert_build_finished_get_props(SUCCESS, insert_patch=False)
report = yield self.build_message(g, build)
self.assertEqual(report['patches'], [])
@defer.inlineCallbacks
def test_generate_new(self):
g = yield self.setup_generator()
build = yield self.insert_build_new()
buildset = yield self.get_inserted_buildset()
report = yield self.generate(g, ('builds', 123, 'new'), build)
self.assertEqual(
report,
{
'body': 'start body',
'subject': 'start subject',
'type': 'plain',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_generate_finished(self):
g = yield self.setup_generator()
build = yield self.insert_build_finished_get_props(SUCCESS)
buildset = yield self.get_inserted_buildset()
report = yield self.generate(g, ('builds', 123, 'finished'), build)
self.assertEqual(
report,
{
'body': 'end body',
'subject': 'end subject',
'type': 'plain',
"extra_info": None,
'results': SUCCESS,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_generate_none(self):
g = yield self.setup_generator(builders=['other builder'])
build = yield self.insert_build_new()
build["buildset"] = yield self.get_inserted_buildset()
report = yield self.generate(g, ('builds', 123, 'new'), build)
self.assertIsNone(report, None)
| 19,168 | Python | .py | 484 | 29.256198 | 100 | 0.579177 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,460 | test_utils.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_utils.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import datetime
import textwrap
from dateutil.tz import tzutc
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.reporters import utils
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util import logging
class TestDataUtils(TestReactorMixin, unittest.TestCase, logging.LoggingMixin):
LOGCONTENT = textwrap.dedent("""\
line zero
line 1""")
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setupDb(self):
self.db = self.master.db
yield self.db.insert_test_data([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrk'),
fakedb.Buildset(id=98, results=SUCCESS, reason="testReason1"),
fakedb.Buildset(id=99, results=SUCCESS, reason="testReason2", parent_buildid=21),
fakedb.Builder(id=80, name='Builder1'),
fakedb.Builder(id=81, name='Builder2'),
fakedb.BuildRequest(id=9, buildsetid=97, builderid=80),
fakedb.BuildRequest(id=10, buildsetid=97, builderid=80),
fakedb.BuildRequest(id=11, buildsetid=98, builderid=80),
fakedb.BuildRequest(id=12, buildsetid=98, builderid=80),
fakedb.BuildRequest(id=13, buildsetid=99, builderid=81),
fakedb.Build(
id=18,
number=0,
builderid=80,
buildrequestid=9,
workerid=13,
masterid=92,
results=FAILURE,
),
fakedb.Build(
id=19,
number=1,
builderid=80,
buildrequestid=10,
workerid=13,
masterid=92,
results=RETRY,
),
fakedb.Build(
id=20,
number=2,
builderid=80,
buildrequestid=11,
workerid=13,
masterid=92,
results=SUCCESS,
),
fakedb.Build(
id=21,
number=3,
builderid=80,
buildrequestid=12,
workerid=13,
masterid=92,
results=SUCCESS,
),
fakedb.Build(
id=22,
number=1,
builderid=81,
buildrequestid=13,
workerid=13,
masterid=92,
results=SUCCESS,
),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.SourceStamp(id=234),
fakedb.Change(
changeid=13,
branch='trunk',
revision='9283',
author='me@foo',
repository='svn://...',
codebase='cbsvn',
project='world-domination',
sourcestampid=234,
),
fakedb.Patch(
id=99,
patch_base64='aGVsbG8sIHdvcmxk',
patch_author='him@foo',
patch_comment='foo',
subdir='/foo',
patchlevel=3,
),
fakedb.SourceStamp(id=235, patchid=99),
])
for _id in (20, 21):
yield self.db.insert_test_data([
fakedb.BuildProperty(buildid=_id, name="workername", value="wrk"),
fakedb.BuildProperty(buildid=_id, name="reason", value="because"),
fakedb.BuildProperty(buildid=_id, name="owner", value="him"),
fakedb.Step(id=100 + _id, number=29, buildid=_id, name="step1"),
fakedb.Step(id=200 + _id, number=30, buildid=_id, name="step2"),
fakedb.Log(
id=60 + _id, stepid=100 + _id, name='stdio', slug='stdio', type='s', num_lines=2
),
fakedb.LogChunk(
logid=60 + _id, first_line=0, last_line=1, compressed=0, content=self.LOGCONTENT
),
])
@defer.inlineCallbacks
def getChangesForBuild(buildid):
assert buildid == 20
ch = yield self.master.db.changes.getChange(13)
return [ch]
self.master.db.changes.getChangesForBuild = getChangesForBuild
@parameterized.expand([
('disabled', 'log', 'step', False, False),
('enabled', 'log', 'step', True, True),
('empty_list', 'log', 'step', [], False),
('name_no_match', 'log', 'step', ['log2'], False),
('name_match', 'log', 'step', ['log'], True),
('name_match_step_no_match', 'log', 'step', ['step2.log'], False),
('name_no_match_step_match', 'log', 'step', ['step.log2'], False),
('name_match_step_match', 'log', 'step', ['step.log'], True),
])
def test_should_attach_log(self, name, log_name, step_name, log_config, expected):
log = {'name': log_name, 'stepname': step_name}
self.assertEqual(utils.should_attach_log(log_config, log), expected)
@defer.inlineCallbacks
def test_getDetailsForBuildset(self):
yield self.setupDb()
res = yield utils.getDetailsForBuildset(
self.master, 98, want_properties=True, want_steps=True, want_previous_build=True
)
self.assertEqual(len(res['builds']), 2)
build1 = res['builds'][0]
build2 = res['builds'][1]
buildset = res['buildset']
self.assertEqual(
build1['properties'],
{
'reason': ('because', 'fakedb'),
'owner': ('him', 'fakedb'),
'workername': ('wrk', 'fakedb'),
},
)
self.assertEqual(len(build1['steps']), 2)
self.assertEqual(build1['buildid'], 20)
self.assertEqual(build2['buildid'], 21)
self.assertEqual(buildset['bsid'], 98)
# make sure prev_build was computed
self.assertEqual(build1['prev_build']['buildid'], 18)
self.assertEqual(build2['prev_build']['buildid'], 20)
@defer.inlineCallbacks
def test_getDetailsForBuild(self):
yield self.setupDb()
build = yield self.master.data.get(("builds", 21))
yield utils.getDetailsForBuild(
self.master,
build,
want_properties=False,
want_steps=False,
want_previous_build=False,
want_logs=False,
)
self.assertEqual(build['parentbuild'], None)
self.assertEqual(build['parentbuilder'], None)
@defer.inlineCallbacks
def test_getDetailsForBuildWithParent(self):
yield self.setupDb()
build = yield self.master.data.get(("builds", 22))
yield utils.getDetailsForBuild(
self.master,
build,
want_properties=False,
want_steps=False,
want_previous_build=False,
want_logs=False,
)
self.assertEqual(build['parentbuild']['buildid'], 21)
self.assertEqual(build['parentbuilder']['name'], "Builder1")
@defer.inlineCallbacks
def test_getDetailsForBuildsetWithLogs(self):
yield self.setupDb()
res = yield utils.getDetailsForBuildset(
self.master,
98,
want_properties=True,
want_steps=True,
want_previous_build=True,
want_logs=True,
want_logs_content=True,
)
build1 = res['builds'][0]
self.assertEqual(
build1['steps'][0]['logs'][0]['content']['content'], self.LOGCONTENT + "\n"
)
self.assertEqual(
build1['steps'][0]['logs'][0]['url'],
'http://localhost:8080/#/builders/80/builds/2/steps/29/logs/stdio',
)
@defer.inlineCallbacks
def test_get_details_for_buildset_all(self):
yield self.setupDb()
self.maxDiff = None
res = yield utils.getDetailsForBuildset(
self.master,
98,
want_properties=True,
want_steps=True,
want_previous_build=True,
want_logs=True,
want_logs_content=True,
)
self.assertEqual(
res,
{
'builds': [
{
'builder': {
'builderid': 80,
'description': None,
'description_format': None,
'description_html': None,
'projectid': None,
'masterids': [],
'name': 'Builder1',
'tags': [],
},
'builderid': 80,
'buildid': 20,
'buildrequestid': 11,
'buildset': {
'bsid': 98,
'complete': False,
'complete_at': None,
'external_idstring': 'extid',
'rebuilt_buildid': None,
'parent_buildid': None,
'parent_relationship': None,
'reason': 'testReason1',
'results': 0,
'sourcestamps': [
{
'branch': 'master',
'codebase': '',
'created_at': datetime.datetime(
1972, 11, 5, 18, 7, 14, tzinfo=tzutc()
),
'patch': None,
'project': 'proj',
'repository': 'repo',
'revision': 'rev-234',
'ssid': 234,
}
],
'submitted_at': 12345678,
},
'complete': False,
'complete_at': None,
"locks_duration_s": 0,
'masterid': 92,
'number': 2,
'prev_build': {
'builderid': 80,
'buildid': 18,
'buildrequestid': 9,
'complete': False,
'complete_at': None,
"locks_duration_s": 0,
'masterid': 92,
'number': 0,
'properties': {},
'results': 2,
'started_at': datetime.datetime(2011, 5, 1, 15, 3, 42, tzinfo=tzutc()),
'state_string': 'test',
'workerid': 13,
},
'properties': {
'owner': ('him', 'fakedb'),
'reason': ('because', 'fakedb'),
'workername': ('wrk', 'fakedb'),
},
'results': 0,
'started_at': datetime.datetime(2011, 5, 1, 15, 3, 42, tzinfo=tzutc()),
'state_string': 'test',
'steps': [
{
'buildid': 20,
'complete': False,
'complete_at': None,
'hidden': False,
"locks_acquired_at": None,
'logs': [
{
'complete': False,
'content': {
'content': 'line zero\nline 1\n',
'firstline': 0,
'logid': 80,
},
'logid': 80,
'name': 'stdio',
'num_lines': 2,
'slug': 'stdio',
'stepid': 120,
'stepname': 'step1',
'type': 's',
'url': 'http://localhost:8080/#/builders/80/builds/2/steps/29/logs/stdio',
'url_raw': 'http://localhost:8080/api/v2/logs/80/raw',
'url_raw_inline': 'http://localhost:8080/api/v2/logs/80/raw_inline',
}
],
'name': 'step1',
'number': 29,
'results': None,
'started_at': datetime.datetime(
2011, 5, 1, 15, 3, 42, tzinfo=tzutc()
),
'state_string': '',
'stepid': 120,
'urls': [],
},
{
'buildid': 20,
'complete': False,
'complete_at': None,
'hidden': False,
"locks_acquired_at": None,
'logs': [],
'name': 'step2',
'number': 30,
'results': None,
'started_at': datetime.datetime(
2011, 5, 1, 15, 3, 42, tzinfo=tzutc()
),
'state_string': '',
'stepid': 220,
'urls': [],
},
],
'url': 'http://localhost:8080/#/builders/80/builds/2',
'workerid': 13,
},
{
'builder': {
'builderid': 80,
'description': None,
'description_format': None,
'description_html': None,
'projectid': None,
'masterids': [],
'name': 'Builder1',
'tags': [],
},
'builderid': 80,
'buildid': 21,
'buildrequestid': 12,
'buildset': {
'bsid': 98,
'complete': False,
'complete_at': None,
'external_idstring': 'extid',
'rebuilt_buildid': None,
'parent_buildid': None,
'parent_relationship': None,
'reason': 'testReason1',
'results': 0,
'sourcestamps': [
{
'branch': 'master',
'codebase': '',
'created_at': datetime.datetime(
1972, 11, 5, 18, 7, 14, tzinfo=tzutc()
),
'patch': None,
'project': 'proj',
'repository': 'repo',
'revision': 'rev-234',
'ssid': 234,
}
],
'submitted_at': 12345678,
},
'complete': False,
'complete_at': None,
"locks_duration_s": 0,
'masterid': 92,
'number': 3,
'prev_build': {
'builderid': 80,
'buildid': 20,
'buildrequestid': 11,
'complete': False,
'complete_at': None,
"locks_duration_s": 0,
'masterid': 92,
'number': 2,
'properties': {},
'results': 0,
'started_at': datetime.datetime(2011, 5, 1, 15, 3, 42, tzinfo=tzutc()),
'state_string': 'test',
'workerid': 13,
},
'properties': {
'owner': ('him', 'fakedb'),
'reason': ('because', 'fakedb'),
'workername': ('wrk', 'fakedb'),
},
'results': 0,
'started_at': datetime.datetime(2011, 5, 1, 15, 3, 42, tzinfo=tzutc()),
'state_string': 'test',
'steps': [
{
'buildid': 21,
'complete': False,
'complete_at': None,
'hidden': False,
"locks_acquired_at": None,
'logs': [
{
'complete': False,
'content': {
'content': 'line zero\nline 1\n',
'firstline': 0,
'logid': 81,
},
'logid': 81,
'name': 'stdio',
'num_lines': 2,
'slug': 'stdio',
'stepid': 121,
'stepname': 'step1',
'type': 's',
'url': 'http://localhost:8080/#/builders/80/builds/3/steps/29/logs/stdio',
'url_raw': 'http://localhost:8080/api/v2/logs/81/raw',
'url_raw_inline': 'http://localhost:8080/api/v2/logs/81/raw_inline',
}
],
'name': 'step1',
'number': 29,
'results': None,
'started_at': datetime.datetime(
2011, 5, 1, 15, 3, 42, tzinfo=tzutc()
),
'state_string': '',
'stepid': 121,
'urls': [],
},
{
'buildid': 21,
'complete': False,
'complete_at': None,
'hidden': False,
"locks_acquired_at": None,
'logs': [],
'name': 'step2',
'number': 30,
'results': None,
'started_at': datetime.datetime(
2011, 5, 1, 15, 3, 42, tzinfo=tzutc()
),
'state_string': '',
'stepid': 221,
'urls': [],
},
],
'url': 'http://localhost:8080/#/builders/80/builds/3',
'workerid': 13,
},
],
'buildset': {
'bsid': 98,
'complete': False,
'complete_at': None,
'external_idstring': 'extid',
'rebuilt_buildid': None,
'parent_buildid': None,
'parent_relationship': None,
'reason': 'testReason1',
'results': 0,
'sourcestamps': [
{
'branch': 'master',
'codebase': '',
'created_at': datetime.datetime(1972, 11, 5, 18, 7, 14, tzinfo=tzutc()),
'patch': None,
'project': 'proj',
'repository': 'repo',
'revision': 'rev-234',
'ssid': 234,
}
],
'submitted_at': 12345678,
},
},
)
@defer.inlineCallbacks
def test_getResponsibleUsers(self):
yield self.setupDb()
res = yield utils.getResponsibleUsersForSourceStamp(self.master, 234)
self.assertEqual(res, ["me@foo"])
@defer.inlineCallbacks
def test_getResponsibleUsersFromPatch(self):
yield self.setupDb()
res = yield utils.getResponsibleUsersForSourceStamp(self.master, 235)
self.assertEqual(res, ["him@foo"])
@defer.inlineCallbacks
def test_getResponsibleUsersForBuild(self):
yield self.setupDb()
res = yield utils.getResponsibleUsersForBuild(self.master, 20)
self.assertEqual(sorted(res), sorted(["me@foo", "him"]))
@defer.inlineCallbacks
def test_getResponsibleUsersForBuildWithBadOwner(self):
self.setUpLogging()
yield self.setupDb()
yield self.db.insert_test_data([
fakedb.BuildProperty(buildid=20, name="owner", value=["him"]),
])
res = yield utils.getResponsibleUsersForBuild(self.master, 20)
self.assertLogged("Please report a bug")
self.assertEqual(sorted(res), sorted(["me@foo", "him"]))
@defer.inlineCallbacks
def test_getResponsibleUsersForBuildWithOwners(self):
yield self.setupDb()
yield self.db.insert_test_data([
fakedb.BuildProperty(buildid=20, name="owners", value=["him", "her"]),
])
res = yield utils.getResponsibleUsersForBuild(self.master, 20)
self.assertEqual(sorted(res), sorted(["me@foo", "him", "her"]))
@defer.inlineCallbacks
def test_get_responsible_users_for_buildset_with_owner(self):
yield self.setupDb()
yield self.db.insert_test_data([
fakedb.BuildsetProperty(
buildsetid=98, property_name="owner", property_value='["buildset_owner", "fakedb"]'
),
])
res = yield utils.get_responsible_users_for_buildset(self.master, 98)
self.assertEqual(sorted(res), sorted(["buildset_owner"]))
@defer.inlineCallbacks
def test_get_responsible_users_for_buildset_no_owner(self):
yield self.setupDb()
res = yield utils.get_responsible_users_for_buildset(self.master, 99)
self.assertEqual(sorted(res), sorted([]))
@defer.inlineCallbacks
def test_getPreviousBuild(self):
yield self.setupDb()
build = yield self.master.data.get(("builds", 21))
res = yield utils.getPreviousBuild(self.master, build)
self.assertEqual(res['buildid'], 20)
@defer.inlineCallbacks
def test_getPreviousBuildWithRetry(self):
yield self.setupDb()
build = yield self.master.data.get(("builds", 20))
res = yield utils.getPreviousBuild(self.master, build)
self.assertEqual(res['buildid'], 18)
class TestURLUtils(TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def test_UrlForBuild(self):
self.assertEqual(
utils.getURLForBuild(self.master, 1, 3), 'http://localhost:8080/#/builders/1/builds/3'
)
| 26,315 | Python | .py | 595 | 24.268908 | 114 | 0.414421 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,461 | test_github.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_github.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.properties import Interpolate
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.reporters.github import HOSTED_BASE_URL
from buildbot.reporters.github import GitHubCommentPush
from buildbot.reporters.github import GitHubStatusPush
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.reporter import ReporterTestMixin
class TestGitHubStatusPush(
TestReactorMixin, unittest.TestCase, ConfigErrorsMixin, ReporterTestMixin
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
# project must be in the form <owner>/<project>
self.reporter_test_project = 'buildbot/buildbot'
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
yield self.master.startService()
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master,
self,
HOSTED_BASE_URL,
headers={'User-Agent': 'Buildbot'},
debug=None,
verify=None,
)
self.sp = self.createService()
yield self.sp.setServiceParent(self.master)
def createService(self):
return GitHubStatusPush(Interpolate('XXYYZZ'))
@defer.inlineCallbacks
def tearDown(self):
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_basic(self):
build = yield self.insert_build_new()
self._http.expect(
'post',
'/repos/buildbot/buildbot/statuses/d34db33fd43db33f',
json={
'state': 'pending',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build started.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/buildbot/buildbot/statuses/d34db33fd43db33f',
json={
'state': 'success',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/buildbot/buildbot/statuses/d34db33fd43db33f',
json={
'state': 'failure',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
build['complete'] = False
build['results'] = None
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_empty(self):
build = yield self.insert_build_new(insert_ss=False)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_source_stamp_no_props_nightly_scheduler(self):
# no status updates are expected
yield self.master.db.insert_test_data([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrk'),
fakedb.Builder(id=79, name='Builder0'),
fakedb.Buildset(id=98, results=SUCCESS, reason="test_reason1"),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.SourceStamp(
id=234, project='', branch=None, revision=None, repository='repo', codebase='cb'
),
fakedb.BuildRequest(id=11, buildsetid=98, builderid=79),
fakedb.Build(
id=20,
number=0,
builderid=79,
buildrequestid=11,
workerid=13,
masterid=92,
results=SUCCESS,
state_string="build_text",
),
fakedb.BuildProperty(buildid=20, name="workername", value="wrk"),
fakedb.BuildProperty(buildid=20, name="reason", value="because"),
fakedb.BuildProperty(buildid=20, name="buildername", value="Builder0"),
fakedb.BuildProperty(buildid=20, name="branch", value=None),
fakedb.BuildProperty(buildid=20, name="codebase", value=""),
fakedb.BuildProperty(buildid=20, name="project", value=""),
fakedb.BuildProperty(buildid=20, name="repository", value=""),
fakedb.BuildProperty(buildid=20, name="revision", value=None),
])
self.setup_fake_get_changes_for_build(has_change=False)
build = yield self.master.data.get(("builds", 20))
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_multiple_source_stamps_no_props(self):
repository = 'http://test_repo'
project = 'test_user/test_project'
codebase1 = 'test_codebase1'
codebase2 = 'test_codebase2'
codebase3 = 'test_codebase3'
self._http.expect(
'post',
'/repos/test_user/test_project/statuses/rev1',
json={
'state': 'pending',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build started.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/test_user/test_project/statuses/rev3',
json={
'state': 'pending',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build started.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/test_user/test_project/statuses/rev1',
json={
'state': 'success',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/test_user/test_project/statuses/rev3',
json={
'state': 'success',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/test_user/test_project/statuses/rev1',
json={
'state': 'success',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/test_user/test_project/statuses/rev3',
json={
'state': 'success',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
# note that the first sourcestamp only has revision, second only branch and only the third
# has both
yield self.master.db.insert_test_data([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrk'),
fakedb.Builder(id=79, name='Builder0'),
fakedb.Buildset(id=98, results=SUCCESS, reason="test_reason1"),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=235),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=236),
fakedb.SourceStamp(
id=234,
project=project,
branch=None,
revision='rev1',
repository=repository,
codebase=codebase1,
),
fakedb.SourceStamp(
id=235,
project=project,
branch='branch2',
revision=None,
repository=repository,
codebase=codebase2,
),
fakedb.SourceStamp(
id=236,
project=project,
branch='branch3',
revision='rev3',
repository=repository,
codebase=codebase3,
),
fakedb.BuildRequest(id=11, buildsetid=98, builderid=79),
fakedb.Build(
id=20,
number=0,
builderid=79,
buildrequestid=11,
workerid=13,
masterid=92,
results=SUCCESS,
state_string="build_text",
),
fakedb.BuildProperty(buildid=20, name="buildername", value="Builder0"),
])
self.setup_fake_get_changes_for_build(has_change=False)
build = yield self.master.data.get(("builds", 20))
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
class TestGitHubStatusPushURL(TestReactorMixin, unittest.TestCase, ReporterTestMixin):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
# project must be in the form <owner>/<project>
self.reporter_test_project = 'buildbot'
self.reporter_test_repo = 'https://github.com/buildbot1/buildbot1.git'
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
yield self.master.startService()
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master,
self,
HOSTED_BASE_URL,
headers={'User-Agent': 'Buildbot'},
debug=None,
verify=None,
)
self.sp = self.createService()
yield self.sp.setServiceParent(self.master)
def createService(self):
return GitHubStatusPush('XXYYZZ')
@defer.inlineCallbacks
def tearDown(self):
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_ssh(self):
self.reporter_test_repo = '[email protected]:buildbot2/buildbot2.git'
build = yield self.insert_build_new()
self._http.expect(
'post',
'/repos/buildbot2/buildbot2/statuses/d34db33fd43db33f',
json={
'state': 'pending',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build started.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/buildbot2/buildbot2/statuses/d34db33fd43db33f',
json={
'state': 'success',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/buildbot2/buildbot2/statuses/d34db33fd43db33f',
json={
'state': 'failure',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_https(self):
build = yield self.insert_build_new()
self._http.expect(
'post',
'/repos/buildbot1/buildbot1/statuses/d34db33fd43db33f',
json={
'state': 'pending',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build started.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/buildbot1/buildbot1/statuses/d34db33fd43db33f',
json={
'state': 'success',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/buildbot1/buildbot1/statuses/d34db33fd43db33f',
json={
'state': 'failure',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'description': 'Build done.',
'context': 'buildbot/Builder0',
},
headers={'Authorization': 'token XXYYZZ'},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
class TestGitHubCommentPush(TestGitHubStatusPush):
def createService(self):
return GitHubCommentPush('XXYYZZ')
@defer.inlineCallbacks
def test_basic(self):
build = yield self.insert_build_new()
self._http.expect(
'post',
'/repos/buildbot/buildbot/issues/34/comments',
json={'body': 'Build done.'},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/buildbot/buildbot/issues/34/comments',
json={'body': 'Build done.'},
headers={'Authorization': 'token XXYYZZ'},
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_empty(self):
build = yield self.insert_build_new(insert_ss=False)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_basic_branch_head(self):
self.reporter_test_props['branch'] = 'refs/pull/13/head'
build = yield self.insert_build_new()
self._http.expect(
'post',
'/repos/buildbot/buildbot/issues/13/comments',
json={'body': 'Build done.'},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/buildbot/buildbot/issues/13/comments',
json={'body': 'Build done.'},
headers={'Authorization': 'token XXYYZZ'},
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_multiple_source_stamps_no_props(self):
repository = 'http://test_repo'
project = 'test_user/test_project'
codebase1 = 'test_codebase1'
codebase2 = 'test_codebase2'
codebase3 = 'test_codebase3'
branch2 = 'refs/pull/4192/merge'
branch3 = 'refs/pull/4193/merge'
self._http.expect(
'post',
'/repos/test_user/test_project/issues/4192/comments',
json={'body': 'Build done.'},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/test_user/test_project/issues/4192/comments',
json={'body': 'Build done.'},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/test_user/test_project/issues/4192/comments',
json={'body': 'Build done.'},
headers={'Authorization': 'token XXYYZZ'},
)
self._http.expect(
'post',
'/repos/test_user/test_project/issues/4192/comments',
json={'body': 'Build done.'},
headers={'Authorization': 'token XXYYZZ'},
)
# note that the first sourcestamp only has revision, second only branch and only the third
# has both
yield self.master.db.insert_test_data([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrk'),
fakedb.Builder(id=79, name='Builder0'),
fakedb.Buildset(id=98, results=SUCCESS, reason="test_reason1"),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=235),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=236),
fakedb.SourceStamp(
id=234,
project=project,
branch=None,
revision='rev1',
repository=repository,
codebase=codebase1,
),
fakedb.SourceStamp(
id=235,
project=project,
branch=branch2,
revision=None,
repository=repository,
codebase=codebase2,
),
fakedb.SourceStamp(
id=236,
project=project,
branch=branch3,
revision='rev3',
repository=repository,
codebase=codebase3,
),
fakedb.BuildRequest(id=11, buildsetid=98, builderid=79),
fakedb.Build(
id=20,
number=0,
builderid=79,
buildrequestid=11,
workerid=13,
masterid=92,
results=SUCCESS,
state_string="build_text",
),
fakedb.BuildProperty(buildid=20, name="buildername", value="Builder0"),
fakedb.BuildProperty(buildid=20, name="branch", value=branch2),
])
self.setup_fake_get_changes_for_build(has_change=False)
build = yield self.master.data.get(("builds", 20))
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
| 21,981 | Python | .py | 533 | 29.763602 | 98 | 0.565187 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,462 | test_generators_buildset.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_generators_buildset.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest.mock import Mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.results import SUCCESS
from buildbot.reporters import utils
from buildbot.reporters.generators.buildset import BuildSetCombinedStatusGenerator
from buildbot.reporters.generators.buildset import BuildSetStatusGenerator
from buildbot.reporters.message import MessageFormatter
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.reporter import ReporterTestMixin
class TestBuildSetGeneratorBase(
ConfigErrorsMixin, TestReactorMixin, ReporterTestMixin, unittest.TestCase
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def insert_build_finished_get_props(self, results, **kwargs):
build = yield self.insert_build_finished(results, **kwargs)
yield utils.getDetailsForBuild(self.master, build, want_properties=True)
return build
@defer.inlineCallbacks
def setup_generator(
self, results=SUCCESS, message=None, db_args=None, insert_build=True, **kwargs
):
if message is None:
message = {
"body": "body",
"type": "text",
"subject": "subject",
"extra_info": None,
}
if db_args is None:
db_args = {}
if insert_build:
build = yield self.insert_build_finished_get_props(results, **db_args)
buildset = yield self.get_inserted_buildset()
else:
build = None
buildset = yield self.insert_buildset_no_builds(results, **db_args)
formatter = Mock(spec=MessageFormatter())
formatter.format_message_for_build.return_value = message
formatter.format_message_for_buildset.return_value = message
formatter.want_logs = False
formatter.want_logs_content = False
formatter.want_steps = False
g = self.GENERATOR_CLASS(message_formatter=formatter, **kwargs)
return (g, build, buildset)
class TestBuildSetGenerator(TestBuildSetGeneratorBase):
# Note: most of the functionality of BuildSetStatusGenerator is shared with
# BuildStatusGenerator and is tested there.
GENERATOR_CLASS = BuildSetStatusGenerator
@defer.inlineCallbacks
def buildset_message(self, g, builds, buildset):
reporter = Mock()
reporter.getResponsibleUsersForBuild.return_value = []
report = yield g.buildset_message(g.formatter, self.master, reporter, builds, buildset)
return report
@defer.inlineCallbacks
def generate(self, g, key, build):
reporter = Mock()
reporter.getResponsibleUsersForBuild.return_value = []
report = yield g.generate(self.master, reporter, key, build)
return report
@defer.inlineCallbacks
def test_buildset_message_nominal(self):
g, build, buildset = yield self.setup_generator(mode=("change",))
report = yield self.buildset_message(g, [build], buildset)
g.formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=True, mode=('change',), users=[]
)
self.assertEqual(
report,
{
'body': 'body',
'subject': 'subject',
'type': 'text',
"extra_info": None,
'results': SUCCESS,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_buildset_message_no_result(self):
g, build, buildset = yield self.setup_generator(results=None, mode=("change",))
buildset["results"] = None
report = yield self.buildset_message(g, [build], buildset)
g.formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=True, mode=('change',), users=[]
)
self.assertEqual(
report,
{
'body': 'body',
'subject': 'subject',
'type': 'text',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_buildset_message_no_result_formatter_no_subject(self):
message = {
"body": "body",
"type": "text",
"subject": None, # deprecated unspecified subject
"extra_info": None,
}
g, build, buildset = yield self.setup_generator(
results=None, message=message, mode=("change",)
)
buildset["results"] = None
report = yield self.buildset_message(g, [build], buildset)
g.formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=True, mode=('change',), users=[]
)
self.assertEqual(
report,
{
'body': 'body',
'subject': 'Buildbot not finished in Buildbot on whole buildset',
'type': 'text',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_generate_complete(self):
g, build, buildset = yield self.setup_generator()
report = yield self.generate(g, ('buildsets', 98, 'complete'), buildset)
# we retrieve build data differently when processing the buildset, so adjust it to match
del build['buildrequest']
del build['parentbuild']
del build['parentbuilder']
self.assertEqual(
report,
{
'body': 'body',
'subject': 'subject',
'type': 'text',
"extra_info": None,
'results': SUCCESS,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_generate_complete_no_builds(self):
g, _, buildset = yield self.setup_generator(insert_build=False)
report = yield self.generate(g, ('buildsets', 98, 'complete'), buildset)
g.formatter.format_message_for_build.assert_not_called()
self.assertIsNone(report)
@defer.inlineCallbacks
def test_generate_complete_non_matching_builder(self):
g, _, buildset = yield self.setup_generator(builders=['non-matched'])
report = yield self.generate(g, ('buildsets', 98, 'complete'), buildset)
g.formatter.format_message_for_build.assert_not_called()
self.assertIsNone(report)
@defer.inlineCallbacks
def test_generate_complete_non_matching_result(self):
g, _, buildset = yield self.setup_generator(mode=('failing',))
report = yield self.generate(g, ('buildsets', 98, 'complete'), buildset)
g.formatter.format_message_for_build.assert_not_called()
self.assertIsNone(report)
class TestBuildSetCombinedGenerator(TestBuildSetGeneratorBase):
GENERATOR_CLASS = BuildSetCombinedStatusGenerator
@defer.inlineCallbacks
def buildset_message(self, g, buildset, builds):
reporter = Mock()
report = yield g.buildset_message(g.formatter, self.master, reporter, buildset, builds)
return report
@defer.inlineCallbacks
def generate(self, g, key, buildset):
report = yield g.generate(self.master, Mock(), key, buildset)
return report
@defer.inlineCallbacks
def test_buildset_message_normal(self):
g, build, buildset = yield self.setup_generator()
report = yield self.buildset_message(g, buildset, [build])
g.formatter.format_message_for_buildset.assert_called_with(
self.master, buildset, [build], is_buildset=True, mode=("passing",), users=[]
)
# we retrieve build data differently when processing the buildset, so adjust it to match
del build['buildrequest']
del build['parentbuild']
del build['parentbuilder']
self.assertEqual(
report,
{
"body": "body",
"subject": "subject",
"type": "text",
"extra_info": None,
"results": SUCCESS,
"builds": [build],
"buildset": buildset,
"users": [],
"patches": [],
"logs": [],
},
)
@defer.inlineCallbacks
def test_buildset_message_no_builds(self):
g, _, buildset = yield self.setup_generator(insert_build=False)
report = yield self.buildset_message(g, buildset, [])
g.formatter.format_message_for_buildset.assert_called_with(
self.master, buildset, [], is_buildset=True, mode=("passing",), users=[]
)
self.assertEqual(
report,
{
"body": "body",
"subject": "subject",
"type": "text",
"extra_info": None,
"results": SUCCESS,
"builds": [],
"buildset": buildset,
"users": [],
"patches": [],
"logs": [],
},
)
@defer.inlineCallbacks
def test_buildset_message_no_result(self):
g, build, buildset = yield self.setup_generator(results=None)
buildset["results"] = None
report = yield self.buildset_message(g, buildset, [build])
g.formatter.format_message_for_buildset.assert_called_with(
self.master, buildset, [build], is_buildset=True, mode=("passing",), users=[]
)
# we retrieve build data differently when processing the buildset, so adjust it to match
del build['buildrequest']
del build['parentbuild']
del build['parentbuilder']
self.assertEqual(
report,
{
"body": "body",
"subject": "subject",
"type": "text",
"extra_info": None,
"results": None,
"builds": [build],
"buildset": buildset,
"users": [],
"patches": [],
"logs": [],
},
)
@defer.inlineCallbacks
def test_buildset_message_no_builds_no_result(self):
g, _, buildset = yield self.setup_generator(results=None, insert_build=False)
buildset["results"] = None
report = yield self.buildset_message(g, buildset, [])
g.formatter.format_message_for_buildset.assert_called_with(
self.master, buildset, [], is_buildset=True, mode=("passing",), users=[]
)
self.assertEqual(
report,
{
"body": "body",
"subject": "subject",
"type": "text",
"extra_info": None,
"results": None,
"builds": [],
"buildset": buildset,
"users": [],
"patches": [],
"logs": [],
},
)
@defer.inlineCallbacks
def test_buildset_message_no_result_formatter_no_subject(self):
message = {
"body": "body",
"type": "text",
"subject": None, # deprecated unspecified subject
"extra_info": None,
}
g, build, buildset = yield self.setup_generator(message=message)
report = yield self.buildset_message(g, buildset, [build])
g.formatter.format_message_for_buildset.assert_called_with(
self.master, buildset, [build], is_buildset=True, mode=("passing",), users=[]
)
# we retrieve build data differently when processing the buildset, so adjust it to match
del build['buildrequest']
del build['parentbuild']
del build['parentbuilder']
self.assertEqual(
report,
{
"body": "body",
"subject": None,
"type": "text",
"extra_info": None,
"results": SUCCESS,
"builds": [build],
"buildset": buildset,
"users": [],
"patches": [],
"logs": [],
},
)
@defer.inlineCallbacks
def test_generate_complete(self):
g, _, buildset = yield self.setup_generator(insert_build=False)
report = yield self.generate(g, ("buildsets", 98, "complete"), buildset)
self.assertEqual(
report,
{
"body": "body",
"subject": "subject",
"type": "text",
"extra_info": None,
"results": SUCCESS,
"builds": [],
"buildset": buildset,
"users": [],
"patches": [],
"logs": [],
},
)
@defer.inlineCallbacks
def test_generate_complete_with_builds(self):
g, build, buildset = yield self.setup_generator(insert_build=True)
report = yield self.generate(g, ("buildsets", 98, "complete"), buildset)
# we retrieve build data differently when processing the buildset, so adjust it to match
del build['buildrequest']
del build['parentbuild']
del build['parentbuilder']
self.assertEqual(
report,
{
"body": "body",
"subject": "subject",
"type": "text",
"extra_info": None,
"results": SUCCESS,
"builds": [build],
"buildset": buildset,
"users": [],
"patches": [],
"logs": [],
},
)
| 15,336 | Python | .py | 385 | 28.844156 | 97 | 0.568962 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,463 | test_pushover.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_pushover.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
import os
from unittest import SkipTest
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.properties import Interpolate
from buildbot.process.results import SUCCESS
from buildbot.reporters.pushover import PushoverNotifier
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.util import httpclientservice
class TestPushoverNotifier(ConfigErrorsMixin, TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
# returns a Deferred
def setupFakeHttp(self):
return fakehttpclientservice.HTTPClientService.getService(
self.master, self, 'https://api.pushover.net'
)
@defer.inlineCallbacks
def setupPushoverNotifier(
self, user_key="1234", api_token: Interpolate | None = None, **kwargs
):
if api_token is None:
api_token = Interpolate("abcd")
pn = PushoverNotifier(user_key, api_token, **kwargs)
yield pn.setServiceParent(self.master)
yield pn.startService()
return pn
@defer.inlineCallbacks
def test_sendMessage(self):
_http = yield self.setupFakeHttp()
pn = yield self.setupPushoverNotifier(priorities={'passing': 2})
_http.expect(
"post",
"/1/messages.json",
params={
'user': "1234",
'token': "abcd",
'message': "Test",
'title': "Tee",
'priority': 2,
},
content_json={'status': 1, 'request': '98765'},
)
n = yield pn.sendMessage([{"body": "Test", "subject": "Tee", "results": SUCCESS}])
j = yield n.json()
self.assertEqual(j['status'], 1)
self.assertEqual(j['request'], '98765')
@defer.inlineCallbacks
def test_sendNotification(self):
_http = yield self.setupFakeHttp()
pn = yield self.setupPushoverNotifier(otherParams={'sound': "silent"})
_http.expect(
"post",
"/1/messages.json",
params={'user': "1234", 'token': "abcd", 'sound': "silent", 'message': "Test"},
content_json={'status': 1, 'request': '98765'},
)
n = yield pn.sendNotification({'message': "Test"})
j = yield n.json()
self.assertEqual(j['status'], 1)
self.assertEqual(j['request'], '98765')
@defer.inlineCallbacks
def test_sendRealNotification(self):
creds = os.environ.get('TEST_PUSHOVER_CREDENTIALS')
if creds is None:
raise SkipTest(
"real pushover test runs only if the variable "
"TEST_PUSHOVER_CREDENTIALS is defined"
)
user, token = creds.split(':')
_http = httpclientservice.HTTPSession(self.master.httpservice, 'https://api.pushover.net')
pn = yield self.setupPushoverNotifier(user_key=user, api_token=token)
n = yield pn.sendNotification({'message': "Buildbot Pushover test passed!"})
j = yield n.json()
self.assertEqual(j['status'], 1)
| 4,234 | Python | .py | 98 | 35.857143 | 98 | 0.668607 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,464 | test_gerrit.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_gerrit.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import warnings
from unittest.mock import Mock
from unittest.mock import call
from packaging.version import parse as parse_version
from parameterized import parameterized
from twisted.internet import defer
from twisted.internet import error
from twisted.internet import reactor
from twisted.python import failure
from twisted.trial import unittest
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.reporters import utils
from buildbot.reporters.generators.build import BuildStartEndStatusGenerator
from buildbot.reporters.generators.buildset import BuildSetStatusGenerator
from buildbot.reporters.gerrit import GERRIT_LABEL_REVIEWED
from buildbot.reporters.gerrit import GERRIT_LABEL_VERIFIED
from buildbot.reporters.gerrit import GerritBuildEndStatusGenerator
from buildbot.reporters.gerrit import GerritBuildSetStatusGenerator
from buildbot.reporters.gerrit import GerritBuildStartStatusGenerator
from buildbot.reporters.gerrit import GerritStatusPush
from buildbot.reporters.gerrit import defaultReviewCB
from buildbot.reporters.gerrit import defaultSummaryCB
from buildbot.reporters.gerrit import extract_project_revision
from buildbot.reporters.gerrit import makeReviewResult
from buildbot.reporters.message import MessageFormatterFunctionRaw
from buildbot.reporters.message import MessageFormatterRenderable
from buildbot.test import fakedb
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.reporter import ReporterTestMixin
warnings.filterwarnings('error', message='.*Gerrit status')
def sampleReviewCB(builderName, build, result, status, arg):
verified = 1 if result == SUCCESS else -1
return makeReviewResult(
str({'name': builderName, 'result': result}), (GERRIT_LABEL_VERIFIED, verified)
)
@defer.inlineCallbacks
def sampleReviewCBDeferred(builderName, build, result, status, arg):
verified = 1 if result == SUCCESS else -1
result = yield makeReviewResult(
str({'name': builderName, 'result': result}), (GERRIT_LABEL_VERIFIED, verified)
)
return result
def sampleStartCB(builderName, build, arg):
return makeReviewResult(str({'name': builderName}), (GERRIT_LABEL_REVIEWED, 0))
@defer.inlineCallbacks
def sampleStartCBDeferred(builderName, build, arg):
result = yield makeReviewResult(str({'name': builderName}), (GERRIT_LABEL_REVIEWED, 0))
return result
def sampleSummaryCB(buildInfoList, results, status, arg):
success = False
failure = False
for buildInfo in buildInfoList:
if buildInfo['result'] == SUCCESS: # pylint: disable=simplifiable-if-statement
success = True
else:
failure = True
if failure:
verified = -1
elif success:
verified = 1
else:
verified = 0
return makeReviewResult(str(buildInfoList), (GERRIT_LABEL_VERIFIED, verified))
@defer.inlineCallbacks
def sampleSummaryCBDeferred(buildInfoList, results, master, arg):
success = False
failure = False
for buildInfo in buildInfoList:
if buildInfo['result'] == SUCCESS: # pylint: disable=simplifiable-if-statement
success = True
else:
failure = True
if failure:
verified = -1
elif success:
verified = 1
else:
verified = 0
result = yield makeReviewResult(str(buildInfoList), (GERRIT_LABEL_VERIFIED, verified))
return result
class TestGerritStatusPush(TestReactorMixin, unittest.TestCase, ReporterTestMixin):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setupGerritStatusPushSimple(self, *args, **kwargs):
serv = kwargs.pop("server", "serv")
username = kwargs.pop("username", "user")
gsp = GerritStatusPush(serv, username, *args, **kwargs)
yield gsp.setServiceParent(self.master)
yield gsp.startService()
return gsp
@defer.inlineCallbacks
def setupGerritStatusPush(self, *args, **kwargs):
gsp = yield self.setupGerritStatusPushSimple(*args, **kwargs)
gsp.send_code_review = Mock()
return gsp
@defer.inlineCallbacks
def setupBuildResults(self, buildResults, finalResult):
yield self.insert_test_data(buildResults, finalResult)
res = yield utils.getDetailsForBuildset(self.master, 98, want_properties=True)
builds = res['builds']
buildset = res['buildset']
@defer.inlineCallbacks
def getChangesForBuild(buildid):
assert buildid == 20
ch = yield self.master.db.changes.getChange(13)
return [ch]
self.master.db.changes.getChangesForBuild = getChangesForBuild
return (buildset, builds)
def makeBuildInfo(self, buildResults, resultText, builds):
info = []
for i, buildResult in enumerate(buildResults):
info.append({
'name': f"Builder{i}",
'result': buildResult,
'resultText': resultText[i],
'text': 'buildText',
'url': f"http://localhost:8080/#/builders/{79 + i}/builds/{i}",
'build': builds[i],
})
return info
@defer.inlineCallbacks
def run_fake_summary_build(self, gsp, buildResults, finalResult, resultText, expWarning=False):
buildset, builds = yield self.setupBuildResults(buildResults, finalResult)
yield gsp._got_event(("buildsets", 98, "complete"), buildset)
info = self.makeBuildInfo(buildResults, resultText, builds)
if expWarning:
self.assertEqual(
[w['message'] for w in self.flushWarnings()],
[
'The Gerrit status callback uses the old '
'way to communicate results. The outcome '
'might be not what is expected.'
],
)
return str(info)
@defer.inlineCallbacks
def check_summary_build_deferred(self, buildResults, finalResult, resultText, verifiedScore):
gsp = yield self.setupGerritStatusPush(
generators=[
GerritBuildSetStatusGenerator(
callback=sampleSummaryCBDeferred,
callback_arg=None,
builders=None,
want_steps=False,
want_logs=False,
)
]
)
msg = yield self.run_fake_summary_build(gsp, buildResults, finalResult, resultText)
gsp.send_code_review.assert_called_once_with(
self.reporter_test_project,
self.reporter_test_revision,
msg,
{GERRIT_LABEL_VERIFIED: verifiedScore},
)
@defer.inlineCallbacks
def check_summary_build(self, buildResults, finalResult, resultText, verifiedScore):
gsp = yield self.setupGerritStatusPush(
generators=[
GerritBuildSetStatusGenerator(
callback=sampleSummaryCB,
callback_arg=None,
builders=None,
want_steps=False,
want_logs=False,
)
]
)
msg = yield self.run_fake_summary_build(gsp, buildResults, finalResult, resultText)
gsp.send_code_review.assert_called_once_with(
self.reporter_test_project,
self.reporter_test_revision,
msg,
{GERRIT_LABEL_VERIFIED: verifiedScore},
)
@defer.inlineCallbacks
def test_gerrit_ssh_cmd(self):
kwargs = {
'server': 'example.com',
'username': 'buildbot',
}
without_identity = yield self.setupGerritStatusPush(**kwargs)
expected1 = [
'ssh',
'-o',
'BatchMode=yes',
'[email protected]',
'-p',
'29418',
'gerrit',
'foo',
]
self.assertEqual(expected1, without_identity._gerritCmd('foo'))
yield without_identity.disownServiceParent()
with_identity = yield self.setupGerritStatusPush(identity_file='/path/to/id_rsa', **kwargs)
expected2 = [
'ssh',
'-o',
'BatchMode=yes',
'-i',
'/path/to/id_rsa',
'[email protected]',
'-p',
'29418',
'gerrit',
'foo',
]
self.assertEqual(expected2, with_identity._gerritCmd('foo'))
def test_buildsetComplete_success_sends_summary_review_deferred(self):
d = self.check_summary_build_deferred(
buildResults=[SUCCESS, SUCCESS],
finalResult=SUCCESS,
resultText=["succeeded", "succeeded"],
verifiedScore=1,
)
return d
def test_buildsetComplete_success_sends_summary_review(self):
d = self.check_summary_build(
buildResults=[SUCCESS, SUCCESS],
finalResult=SUCCESS,
resultText=["succeeded", "succeeded"],
verifiedScore=1,
)
return d
def test_buildsetComplete_failure_sends_summary_review(self):
d = self.check_summary_build(
buildResults=[FAILURE, FAILURE],
finalResult=FAILURE,
resultText=["failed", "failed"],
verifiedScore=-1,
)
return d
def test_buildsetComplete_mixed_sends_summary_review(self):
d = self.check_summary_build(
buildResults=[SUCCESS, FAILURE],
finalResult=FAILURE,
resultText=["succeeded", "failed"],
verifiedScore=-1,
)
return d
@parameterized.expand([
("matched", ["Builder1"], True),
("not_matched", ["foo"], False),
])
@defer.inlineCallbacks
def test_buildset_complete_filtered_builder(self, name, builders, should_call):
gsp = yield self.setupGerritStatusPush(
generators=[
GerritBuildSetStatusGenerator(
callback=sampleSummaryCB,
callback_arg=None,
builders=builders,
want_steps=False,
want_logs=False,
)
]
)
yield self.run_fake_summary_build(gsp, [FAILURE, FAILURE], FAILURE, ["failed", "failed"])
self.assertEqual(gsp.send_code_review.called, should_call)
@defer.inlineCallbacks
def run_fake_single_build(self, gsp, buildResult, expWarning=False):
_, builds = yield self.setupBuildResults([None], None)
yield gsp._got_event(('builds', builds[0]['buildid'], 'new'), builds[0])
yield self.master.db.builds.finishBuild(builds[0]["buildid"], buildResult)
yield self.master.db.buildsets.completeBuildset(98, buildResult)
res = yield utils.getDetailsForBuildset(self.master, 98, want_properties=True)
builds = res['builds']
yield gsp._got_event(('builds', builds[0]['buildid'], 'finished'), builds[0])
if expWarning:
self.assertEqual(
[w['message'] for w in self.flushWarnings()],
[
'The Gerrit status callback uses the old '
'way to communicate results. The outcome '
'might be not what is expected.'
],
)
return str({'name': 'Builder0', 'result': buildResult})
# same goes for check_single_build
@defer.inlineCallbacks
def check_single_build(self, buildResult, verifiedScore):
gsp = yield self.setupGerritStatusPush(
generators=[
GerritBuildEndStatusGenerator(
callback=sampleReviewCB,
callback_arg=None,
builders=None,
want_steps=False,
want_logs=False,
),
GerritBuildStartStatusGenerator(
callback=sampleStartCB,
callback_arg=None,
builders=None,
want_steps=False,
want_logs=False,
),
]
)
msg = yield self.run_fake_single_build(gsp, buildResult)
calls = [
call(
self.reporter_test_project,
self.reporter_test_revision,
str({'name': self.reporter_test_builder_name}),
{GERRIT_LABEL_REVIEWED: 0},
),
call(
self.reporter_test_project,
self.reporter_test_revision,
msg,
{GERRIT_LABEL_VERIFIED: verifiedScore},
),
]
gsp.send_code_review.assert_has_calls(calls)
def test_buildComplete_success_sends_review(self):
return self.check_single_build(SUCCESS, 1)
def test_buildComplete_failure_sends_review(self):
return self.check_single_build(FAILURE, -1)
# same goes for check_single_build
@parameterized.expand([
("matched", ["Builder0"], True),
("not_matched", ["foo"], False),
])
@defer.inlineCallbacks
def test_single_build_filtered(self, name, builders, should_call):
gsp = yield self.setupGerritStatusPush(
generators=[
GerritBuildEndStatusGenerator(
callback=sampleReviewCB,
callback_arg=None,
builders=builders,
want_steps=False,
want_logs=False,
),
GerritBuildStartStatusGenerator(
callback=sampleStartCB,
callback_arg=None,
builders=builders,
want_steps=False,
want_logs=False,
),
]
)
yield self.run_fake_single_build(gsp, SUCCESS)
self.assertEqual(gsp.send_code_review.called, should_call)
@parameterized.expand([
("success", SUCCESS, 1),
("failure", FAILURE, -1),
])
@defer.inlineCallbacks
def test_single_build_generators(self, name, build_result, verified_score):
gsp = yield self.setupGerritStatusPush(generators=[BuildStartEndStatusGenerator()])
yield self.run_fake_single_build(gsp, build_result)
calls = [
call(
self.reporter_test_project,
self.reporter_test_revision,
"Build started.",
{GERRIT_LABEL_VERIFIED: 0},
),
call(
self.reporter_test_project,
self.reporter_test_revision,
"Build done.",
{GERRIT_LABEL_VERIFIED: verified_score},
),
]
gsp.send_code_review.assert_has_calls(calls)
@parameterized.expand([
("success", SUCCESS, 1),
("failure", FAILURE, -1),
])
@defer.inlineCallbacks
def test_single_buildset_generators(self, name, build_result, verified_score):
gsp = yield self.setupGerritStatusPush(
generators=[
BuildSetStatusGenerator(message_formatter=MessageFormatterRenderable("Build done."))
]
)
yield self.run_fake_summary_build(gsp, [build_result], build_result, "text")
calls = [
call(
self.reporter_test_project,
self.reporter_test_revision,
"Build done.",
{GERRIT_LABEL_VERIFIED: verified_score},
)
]
gsp.send_code_review.assert_has_calls(calls)
@defer.inlineCallbacks
def test_single_buildset_generators_override_label(self):
formatter = MessageFormatterFunctionRaw(
lambda _, __: {
"body": "text1",
"type": "plain",
"subject": "sub1",
"extra_info": {"labels": {"Verified": -2}},
}
)
gsp = yield self.setupGerritStatusPush(
generators=[BuildSetStatusGenerator(message_formatter=formatter)]
)
yield self.run_fake_summary_build(gsp, [SUCCESS], SUCCESS, "text")
calls = [
call(
self.reporter_test_project,
self.reporter_test_revision,
"text1",
{GERRIT_LABEL_VERIFIED: -2},
)
]
gsp.send_code_review.assert_has_calls(calls)
def test_defaultReviewCBSuccess(self):
res = defaultReviewCB("builderName", {}, SUCCESS, None, None)
self.assertEqual(res['labels'], {'Verified': 1})
res = defaultReviewCB("builderName", {}, RETRY, None, None)
self.assertEqual(res['labels'], {})
def test_defaultSummaryCB(self):
info = self.makeBuildInfo([SUCCESS, FAILURE], ["yes", "no"], [None, None])
res = defaultSummaryCB(info, SUCCESS, None, None)
self.assertEqual(res['labels'], {'Verified': -1})
info = self.makeBuildInfo([SUCCESS, SUCCESS], ["yes", "yes"], [None, None])
res = defaultSummaryCB(info, SUCCESS, None, None)
self.assertEqual(res['labels'], {'Verified': 1})
@defer.inlineCallbacks
def testBuildGerritCommand(self):
gsp = yield self.setupGerritStatusPushSimple()
spawnSkipFirstArg = Mock()
gsp.spawnProcess = lambda _, *a, **k: spawnSkipFirstArg(*a, **k)
yield gsp.send_code_review("project", "revision", "bla", {'Verified': 1})
spawnSkipFirstArg.assert_called_once_with(
'ssh',
['ssh', '-o', 'BatchMode=yes', 'user@serv', '-p', '29418', 'gerrit', 'version'],
env=None,
)
gsp.processVersion(parse_version("2.6"), lambda: None)
spawnSkipFirstArg = Mock()
yield gsp.send_code_review("project", "revision", "bla", {'Verified': 1})
spawnSkipFirstArg.assert_called_once_with(
'ssh',
[
'ssh',
'-o',
'BatchMode=yes',
'user@serv',
'-p',
'29418',
'gerrit',
'review',
'--project project',
"--message 'bla'",
'--label Verified=1',
'revision',
],
env=None,
)
# <=2.5 uses other syntax
gsp.processVersion(parse_version("2.4"), lambda: None)
spawnSkipFirstArg = Mock()
yield gsp.send_code_review("project", "revision", "bla", {'Verified': 1})
spawnSkipFirstArg.assert_called_once_with(
'ssh',
[
'ssh',
'-o',
'BatchMode=yes',
'user@serv',
'-p',
'29418',
'gerrit',
'review',
'--project project',
"--message 'bla'",
'--verified 1',
'revision',
],
env=None,
)
# now test the notify argument, even though _gerrit_notify
# is private, work around that
gsp._gerrit_notify = 'OWNER'
gsp.processVersion(parse_version('2.6'), lambda: None)
spawnSkipFirstArg = Mock()
yield gsp.send_code_review('project', 'revision', "bla", {'Verified': 1})
spawnSkipFirstArg.assert_called_once_with(
'ssh',
[
'ssh',
'-o',
'BatchMode=yes',
'user@serv',
'-p',
'29418',
'gerrit',
'review',
'--project project',
'--notify OWNER',
"--message 'bla'",
'--label Verified=1',
'revision',
],
env=None,
)
# gerrit versions <= 2.5 uses other syntax
gsp.processVersion(parse_version('2.4'), lambda: None)
spawnSkipFirstArg = Mock()
yield gsp.send_code_review('project', 'revision', "bla", {'Verified': 1})
spawnSkipFirstArg.assert_called_once_with(
'ssh',
[
'ssh',
'-o',
'BatchMode=yes',
'user@serv',
'-p',
'29418',
'gerrit',
'review',
'--project project',
'--notify OWNER',
"--message 'bla'",
'--verified 1',
'revision',
],
env=None,
)
gsp.processVersion(parse_version("2.13"), lambda: None)
spawnSkipFirstArg = Mock()
yield gsp.send_code_review("project", "revision", "bla", {'Verified': 1})
spawnSkipFirstArg.assert_called_once_with(
'ssh',
[
'ssh',
'-o',
'BatchMode=yes',
'user@serv',
'-p',
'29418',
'gerrit',
'review',
'--project project',
'--tag autogenerated:buildbot',
'--notify OWNER',
"--message 'bla'",
'--label Verified=1',
'revision',
],
env=None,
)
@defer.inlineCallbacks
def test_callWithVersion_bytes_output(self):
gsp = yield self.setupGerritStatusPushSimple()
exp_argv = ['ssh', '-o', 'BatchMode=yes', 'user@serv', '-p', '29418', 'gerrit', 'version']
def spawnProcess(pp, cmd, argv, env):
self.assertEqual([cmd, argv], [exp_argv[0], exp_argv])
pp.errReceived(b'test stderr\n')
pp.outReceived(b'gerrit version 2.14\n')
pp.outReceived(b'(garbage that should not cause a crash)\n')
so = error.ProcessDone(None)
pp.processEnded(failure.Failure(so))
self.patch(reactor, 'spawnProcess', spawnProcess)
gsp.callWithVersion(lambda: self.assertEqual(gsp.gerrit_version, parse_version('2.14')))
def test_name_as_class_attribute(self):
class FooStatusPush(GerritStatusPush):
name = 'foo'
reporter = FooStatusPush('gerrit.server.com', 'password')
self.assertEqual(reporter.name, 'foo')
def test_name_as_kwarg(self):
reporter = GerritStatusPush('gerrit.server.com', 'password', name='foo')
self.assertEqual(reporter.name, 'foo')
def test_default_name(self):
reporter = GerritStatusPush('gerrit.server.com', 'password')
self.assertEqual(reporter.name, 'GerritStatusPush')
@defer.inlineCallbacks
def test_extract_project_revision(self):
yield self.insert_test_data([SUCCESS], SUCCESS)
res = yield utils.getDetailsForBuildset(self.master, 98, want_properties=True)
report = {"builds": res["builds"], "buildset": res["buildset"]}
project, revision = yield extract_project_revision(self.master, report)
self.assertEqual(project, "testProject")
self.assertEqual(revision, "d34db33fd43db33f")
@defer.inlineCallbacks
def test_extract_project_revision_no_build(self):
yield self.insert_test_data([], SUCCESS)
yield self.db.insert_test_data([
fakedb.BuildsetProperty(
buildsetid=98, property_name="event.change.id", property_value='["12345", "fakedb"]'
),
fakedb.BuildsetProperty(
buildsetid=98,
property_name="event.change.project",
property_value='["project1", "fakedb"]',
),
fakedb.BuildsetProperty(
buildsetid=98,
property_name="event.patchSet.revision",
property_value='["abcdabcd", "fakedb"]',
),
])
res = yield utils.getDetailsForBuildset(self.master, 98, want_properties=True)
report = {"builds": res["builds"], "buildset": res["buildset"]}
project, revision = yield extract_project_revision(self.master, report)
self.assertEqual(project, "project1")
self.assertEqual(revision, "abcdabcd")
| 25,275 | Python | .py | 629 | 29.17806 | 100 | 0.58768 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,465 | test_generators_worker.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_generators_worker.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.reporters.generators.worker import WorkerMissingGenerator
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
class TestWorkerMissingGenerator(ConfigErrorsMixin, TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
def _get_worker_dict(self, worker_name):
return {
'name': worker_name,
'notify': ["[email protected]"],
'workerinfo': {"admin": "myadmin"},
'last_connection': "yesterday",
}
@parameterized.expand([
(['myworker'],),
('all',),
])
@defer.inlineCallbacks
def test_report_matched_worker(self, worker_filter):
g = WorkerMissingGenerator(workers=worker_filter)
report = yield g.generate(
self.master, None, 'worker.98.complete', self._get_worker_dict('myworker')
)
self.assertEqual(report['users'], ['[email protected]'])
self.assertIn(b"worker named myworker went away", report['body'])
@defer.inlineCallbacks
def test_report_not_matched_worker(self):
g = WorkerMissingGenerator(workers=['other'])
report = yield g.generate(
self.master, None, 'worker.98.complete', self._get_worker_dict('myworker')
)
self.assertIsNone(report)
def test_unsupported_workers(self):
g = WorkerMissingGenerator(workers='string worker')
with self.assertRaisesConfigError("workers must be 'all', or list of worker names"):
g.check()
| 2,687 | Python | .py | 59 | 39.644068 | 97 | 0.717017 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,466 | test_base.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_base.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.results import FAILURE
from buildbot.reporters.base import ReporterBase
from buildbot.reporters.generators.build import BuildStatusGenerator
from buildbot.reporters.generators.worker import WorkerMissingGenerator
from buildbot.reporters.message import MessageFormatter
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.logging import LoggingMixin
from buildbot.test.util.reporter import ReporterTestMixin
class TestException(Exception):
pass
class TestReporterBase(
ConfigErrorsMixin, TestReactorMixin, LoggingMixin, unittest.TestCase, ReporterTestMixin
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.setUpLogging()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setupNotifier(self, generators):
mn = ReporterBase(generators=generators)
mn.sendMessage = mock.Mock(spec=mn.sendMessage)
mn.sendMessage.return_value = "<message>"
yield mn.setServiceParent(self.master)
yield mn.startService()
return mn
@defer.inlineCallbacks
def setup_build_message(self, **kwargs):
build = yield self.insert_build_finished(FAILURE)
buildset = yield self.get_inserted_buildset()
formatter = mock.Mock(spec=MessageFormatter)
formatter.format_message_for_build.return_value = {
"body": "body",
"type": "text",
"subject": "subject",
"extra_info": None,
}
formatter.want_properties = False
formatter.want_steps = False
formatter.want_logs = False
formatter.want_logs_content = False
generator = BuildStatusGenerator(message_formatter=formatter, **kwargs)
mn = yield self.setupNotifier(generators=[generator])
yield mn._got_event(('builds', 20, 'finished'), build)
return (mn, build, buildset, formatter)
def setup_mock_generator(self, events_filter):
gen = mock.Mock()
gen.wanted_event_keys = events_filter
gen.generate_name = lambda: '<name>'
return gen
def test_check_config_raises_error_when_generators_not_list(self):
with self.assertRaisesConfigError('generators argument must be a list'):
ReporterBase(generators='abc')
@defer.inlineCallbacks
def test_buildMessage_nominal(self):
mn, build, buildset, formatter = yield self.setup_build_message(mode=("failing",))
formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=False, mode=('failing',), users=['me@foo']
)
report = {
'body': 'body',
'subject': 'subject',
'type': 'text',
"extra_info": None,
'results': FAILURE,
'builds': [build],
"buildset": buildset,
'users': ['me@foo'],
'patches': [],
'logs': [],
}
self.assertEqual(mn.sendMessage.call_count, 1)
mn.sendMessage.assert_called_with([report])
@defer.inlineCallbacks
def test_worker_missing_sends_message(self):
generator = WorkerMissingGenerator(workers=['myworker'])
mn = yield self.setupNotifier(generators=[generator])
worker_dict = {
'name': 'myworker',
'notify': ["[email protected]"],
'workerinfo': {"admin": "myadmin"},
'last_connection': "yesterday",
}
yield mn._got_event(('workers', 98, 'missing'), worker_dict)
self.assertEqual(mn.sendMessage.call_count, 1)
@defer.inlineCallbacks
def test_generators_subscribes_events(self):
gen1 = self.setup_mock_generator([('fake1', None, None)])
yield self.setupNotifier(generators=[gen1])
self.assertEqual(len(self.master.mq.qrefs), 1)
self.assertEqual(self.master.mq.qrefs[0].filter, ('fake1', None, None))
@defer.inlineCallbacks
def test_generators_subscribes_equal_events_once(self):
gen1 = self.setup_mock_generator([('fake1', None, None)])
gen2 = self.setup_mock_generator([('fake1', None, None)])
yield self.setupNotifier(generators=[gen1, gen2])
self.assertEqual(len(self.master.mq.qrefs), 1)
self.assertEqual(self.master.mq.qrefs[0].filter, ('fake1', None, None))
@defer.inlineCallbacks
def test_generators_subscribes_equal_different_events_once(self):
gen1 = self.setup_mock_generator([('fake1', None, None)])
gen2 = self.setup_mock_generator([('fake2', None, None)])
yield self.setupNotifier(generators=[gen1, gen2])
self.assertEqual(len(self.master.mq.qrefs), 2)
self.assertEqual(self.master.mq.qrefs[0].filter, ('fake1', None, None))
self.assertEqual(self.master.mq.qrefs[1].filter, ('fake2', None, None))
@defer.inlineCallbacks
def test_generators_unsubscribes_on_stop_service(self):
gen1 = self.setup_mock_generator([('fake1', None, None)])
notifier = yield self.setupNotifier(generators=[gen1])
yield notifier.stopService()
self.assertEqual(len(self.master.mq.qrefs), 0)
@defer.inlineCallbacks
def test_generators_resubscribes_on_reconfig(self):
gen1 = self.setup_mock_generator([('fake1', None, None)])
gen2 = self.setup_mock_generator([('fake2', None, None)])
notifier = yield self.setupNotifier(generators=[gen1])
self.assertEqual(len(self.master.mq.qrefs), 1)
self.assertEqual(self.master.mq.qrefs[0].filter, ('fake1', None, None))
yield notifier.reconfigService(generators=[gen2])
self.assertEqual(len(self.master.mq.qrefs), 1)
self.assertEqual(self.master.mq.qrefs[0].filter, ('fake2', None, None))
@defer.inlineCallbacks
def test_generator_throw_exception_on_generate(self):
gen = self.setup_mock_generator([('fake1', None, None)])
@defer.inlineCallbacks
def generate_throw(*args, **kwargs):
raise TestException()
gen.generate = generate_throw
notifier = yield self.setupNotifier(generators=[gen])
yield notifier._got_event(('fake1', None, None), None)
self.assertEqual(len(self.flushLoggedErrors(TestException)), 1)
self.assertLogged('Got exception when handling reporter events')
@defer.inlineCallbacks
def test_reports_sent_in_order_despite_slow_generator(self):
gen = self.setup_mock_generator([('builds', None, None)])
notifier = yield self.setupNotifier(generators=[gen])
# Handle an event when generate is slow
gen.generate = slow_generate = mock.Mock(return_value=defer.Deferred())
notifier._got_event(('builds', None, None), {'buildrequestid': 1})
notifier.sendMessage.assert_not_called()
# Then handle an event when generate is fast
gen.generate = mock.Mock(return_value=defer.Deferred())
gen.generate.return_value.callback(2)
notifier._got_event(('builds', None, None), {'buildrequestid': 1})
# sendMessage still not called
notifier.sendMessage.assert_not_called()
# Have the slow generate finish
slow_generate.return_value.callback(1)
# Now sendMessage should have been called two times
self.assertEqual(notifier.sendMessage.call_args_list, [mock.call([1]), mock.call([2])])
@defer.inlineCallbacks
def test_reports_sent_in_order_despite_multiple_slow_generators(self):
gen = self.setup_mock_generator([('buildrequests', None, None)])
gen2 = self.setup_mock_generator([('builds', None, None)])
notifier = yield self.setupNotifier(generators=[gen, gen2])
# This makes it possible to mock generate calls in arbitrary order
mock_generate_calls = {
'buildrequests': {1: {'new': defer.Deferred()}},
'builds': {1: {'new': defer.Deferred(), 'finished': defer.Deferred()}},
}
def mock_generate(_1, _2, key, msg):
return mock_generate_calls[key[0]][msg['buildrequestid']][key[2]]
gen.generate = mock.Mock(side_effect=mock_generate)
gen2.generate = mock.Mock(side_effect=mock_generate)
# Handle an event when generate is very slow
notifier._got_event(('buildrequests', None, 'new'), {'buildrequestid': 1})
# Handle an event when generate is also slow
notifier._got_event(('builds', None, 'new'), {'buildrequestid': 1})
# Handle an event when generate is fast
mock_generate_calls['builds'][1]['finished'].callback(3)
notifier._got_event(('builds', None, 'finished'), {'buildrequestid': 1})
# Finish generate call for second event
mock_generate_calls['builds'][1]['new'].callback(2)
# sendMessage still not called
notifier.sendMessage.assert_not_called()
# Finish generate call for first event
mock_generate_calls['buildrequests'][1]['new'].callback(1)
# Now sendMessage should have been called three times in given order
self.assertEqual(
notifier.sendMessage.call_args_list, [mock.call([1]), mock.call([2]), mock.call([3])]
)
@defer.inlineCallbacks
def test_reports_sent_in_order_and_asap_for_multiple_builds(self):
gen = self.setup_mock_generator([('builds', None, None)])
notifier = yield self.setupNotifier(generators=[gen])
# This makes it possible to mock generate calls in arbitrary order
mock_generate_calls = {
'builds': {
1: {'new': defer.Deferred(), 'finished': defer.Deferred()},
2: {'new': defer.Deferred(), 'finished': defer.Deferred()},
}
}
def mock_generate(_1, _2, key, msg):
return mock_generate_calls[key[0]][msg['buildrequestid']][key[2]]
gen.generate = mock.Mock(side_effect=mock_generate)
# Handle an event (for first build) when generate is slow
notifier._got_event(('builds', None, 'new'), {'buildrequestid': 1})
notifier.sendMessage.assert_not_called()
# Handle an event (for second build) when generate is fast
mock_generate_calls['builds'][2]['new'].callback(21)
notifier._got_event(('builds', None, 'new'), {'buildrequestid': 2})
# Handle an event (for first build) when generate is fast
mock_generate_calls['builds'][1]['finished'].callback(12)
notifier._got_event(('builds', None, 'finished'), {'buildrequestid': 1})
# Handle an event (for second build) when generate is fast
mock_generate_calls['builds'][2]['finished'].callback(22)
notifier._got_event(('builds', None, 'finished'), {'buildrequestid': 2})
# Finish generate call for first event
mock_generate_calls['builds'][1]['new'].callback(11)
# Now sendMessage should have been called four times in given order
self.assertEqual(
notifier.sendMessage.call_args_list,
[mock.call([21]), mock.call([22]), mock.call([11]), mock.call([12])],
)
| 12,227 | Python | .py | 238 | 43.088235 | 97 | 0.667422 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,467 | test_zulip.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_zulip.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.reporters.zulip import ZulipStatusPush
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.logging import LoggingMixin
from buildbot.test.util.reporter import ReporterTestMixin
class TestZulipStatusPush(
unittest.TestCase, ReporterTestMixin, LoggingMixin, ConfigErrorsMixin, TestReactorMixin
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(
testcase=self, wantData=True, wantDb=True, wantMq=True
)
@defer.inlineCallbacks
def tearDown(self):
if self.master.running:
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setupZulipStatusPush(self, endpoint="http://example.com", token="123", stream=None):
self.sp = ZulipStatusPush(endpoint=endpoint, token=token, stream=stream)
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master, self, endpoint, debug=None, verify=None
)
yield self.sp.setServiceParent(self.master)
yield self.master.startService()
@defer.inlineCallbacks
def test_build_started(self):
yield self.setupZulipStatusPush(stream="xyz")
build = yield self.insert_build_new()
self._http.expect(
'post',
'/api/v1/external/buildbot?api_key=123&stream=xyz',
json={
"event": 'new',
"buildid": 20,
"buildername": "Builder0",
"url": "http://localhost:8080/#/builders/79/builds/0",
"project": "testProject",
"timestamp": 10000001,
},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
@defer.inlineCallbacks
def test_build_finished(self):
yield self.setupZulipStatusPush(stream="xyz")
build = yield self.insert_build_finished()
self._http.expect(
'post',
'/api/v1/external/buildbot?api_key=123&stream=xyz',
json={
"event": "finished",
"buildid": 20,
"buildername": "Builder0",
"url": "http://localhost:8080/#/builders/79/builds/0",
"project": "testProject",
"timestamp": 10000005,
"results": 0,
},
)
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_stream_none(self):
yield self.setupZulipStatusPush(stream=None)
build = yield self.insert_build_finished()
self._http.expect(
'post',
'/api/v1/external/buildbot?api_key=123',
json={
"event": "finished",
"buildid": 20,
"buildername": "Builder0",
"url": "http://localhost:8080/#/builders/79/builds/0",
"project": "testProject",
"timestamp": 10000005,
"results": 0,
},
)
yield self.sp._got_event(('builds', 20, 'finished'), build)
def test_endpoint_string(self):
with self.assertRaisesConfigError("Endpoint must be a string"):
ZulipStatusPush(endpoint=1234, token="abcd")
def test_token_string(self):
with self.assertRaisesConfigError("Token must be a string"):
ZulipStatusPush(endpoint="http://example.com", token=1234)
@defer.inlineCallbacks
def test_invalid_json_data(self):
yield self.setupZulipStatusPush(stream="xyz")
build = yield self.insert_build_new()
self._http.expect(
'post',
'/api/v1/external/buildbot?api_key=123&stream=xyz',
json={
"event": 'new',
"buildid": 20,
"buildername": "Builder0",
"url": "http://localhost:8080/#/builders/79/builds/0",
"project": "testProject",
"timestamp": 10000001,
},
code=500,
)
self.setUpLogging()
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged('500: Error pushing build status to Zulip')
@defer.inlineCallbacks
def test_invalid_url(self):
yield self.setupZulipStatusPush(stream="xyz")
build = yield self.insert_build_new()
self._http.expect(
'post',
'/api/v1/external/buildbot?api_key=123&stream=xyz',
json={
"event": 'new',
"buildid": 20,
"buildername": "Builder0",
"url": "http://localhost:8080/#/builders/79/builds/0",
"project": "testProject",
"timestamp": 10000001,
},
code=404,
)
self.setUpLogging()
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged('404: Error pushing build status to Zulip')
@defer.inlineCallbacks
def test_invalid_token(self):
yield self.setupZulipStatusPush(stream="xyz")
build = yield self.insert_build_new()
self._http.expect(
'post',
'/api/v1/external/buildbot?api_key=123&stream=xyz',
json={
"event": 'new',
"buildid": 20,
"buildername": "Builder0",
"url": "http://localhost:8080/#/builders/79/builds/0",
"project": "testProject",
"timestamp": 10000001,
},
code=401,
content_json={"result": "error", "msg": "Invalid API key", "code": "INVALID_API_KEY"},
)
self.setUpLogging()
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged('401: Error pushing build status to Zulip')
| 6,880 | Python | .py | 166 | 31.445783 | 98 | 0.604776 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,468 | test_gerrit_verify_status.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_gerrit_verify_status.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import datetime
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.properties import Interpolate
from buildbot.process.properties import Properties
from buildbot.process.properties import renderer
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.reporters.generators.build import BuildStartEndStatusGenerator
from buildbot.reporters.gerrit_verify_status import GerritVerifyStatusPush
from buildbot.reporters.message import MessageFormatterRenderable
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util import logging
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.reporter import ReporterTestMixin
class TestGerritVerifyStatusPush(
TestReactorMixin, ReporterTestMixin, ConfigErrorsMixin, logging.LoggingMixin, unittest.TestCase
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.reporter_test_props = {'gerrit_changes': [{'change_id': 12, 'revision_id': 2}]}
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
yield self.master.startService()
@defer.inlineCallbacks
def createGerritStatus(self, **kwargs):
auth = kwargs.pop('auth', ('log', Interpolate('pass')))
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master, self, "gerrit", auth=('log', 'pass'), debug=None, verify=None
)
self.sp = GerritVerifyStatusPush("gerrit", auth=auth, **kwargs)
yield self.sp.setServiceParent(self.master)
@defer.inlineCallbacks
def tearDown(self):
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_basic(self):
yield self.createGerritStatus()
build = yield self.insert_build_new()
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build started.',
'abstain': False,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 0,
'duration': 'pending',
},
)
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build done.',
'abstain': False,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 1,
'duration': '2h 1m 4s',
},
)
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build done.',
'abstain': False,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': -1,
'duration': '2h 1m 4s',
},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['complete_at'] = build['started_at'] + datetime.timedelta(
hours=2, minutes=1, seconds=4
)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_custom_description(self):
start_formatter = MessageFormatterRenderable(Interpolate("started %(prop:buildername)s"))
end_formatter = MessageFormatterRenderable(Interpolate("finished %(prop:buildername)s"))
generator = BuildStartEndStatusGenerator(
start_formatter=start_formatter, end_formatter=end_formatter
)
yield self.createGerritStatus(generators=[generator])
build = yield self.insert_build_new()
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'started Builder0',
'abstain': False,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 0,
'duration': 'pending',
},
)
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'finished Builder0',
'abstain': False,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 1,
'duration': '2h 1m 4s',
},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['complete_at'] = build['started_at'] + datetime.timedelta(
hours=2, minutes=1, seconds=4
)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_custom_name(self):
yield self.createGerritStatus(verification_name=Interpolate("builder %(prop:buildername)s"))
build = yield self.insert_build_new()
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build started.',
'abstain': False,
'name': 'builder Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 0,
'duration': 'pending',
},
)
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build done.',
'abstain': False,
'name': 'builder Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 1,
'duration': '2h 1m 4s',
},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['complete_at'] = build['started_at'] + datetime.timedelta(
hours=2, minutes=1, seconds=4
)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_custom_abstain(self):
yield self.createGerritStatus(
abstain=renderer(lambda p: p.getProperty("buildername") == 'Builder0')
)
build = yield self.insert_build_new()
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build started.',
'abstain': True,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 0,
'duration': 'pending',
},
)
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build done.',
'abstain': True,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 1,
'duration': '2h 1m 4s',
},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['complete_at'] = build['started_at'] + datetime.timedelta(
hours=2, minutes=1, seconds=4
)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_custom_category(self):
yield self.createGerritStatus(category=renderer(lambda p: p.getProperty("buildername")))
build = yield self.insert_build_new()
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build started.',
'abstain': False,
'category': 'Builder0',
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 0,
'duration': 'pending',
},
)
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build done.',
'abstain': False,
'category': 'Builder0',
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 1,
'duration': '2h 1m 4s',
},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['complete_at'] = build['started_at'] + datetime.timedelta(
hours=2, minutes=1, seconds=4
)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_custom_reporter(self):
yield self.createGerritStatus(reporter=renderer(lambda p: p.getProperty("buildername")))
build = yield self.insert_build_new()
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build started.',
'abstain': False,
'name': 'Builder0',
'reporter': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 0,
'duration': 'pending',
},
)
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build done.',
'abstain': False,
'name': 'Builder0',
'reporter': 'Builder0',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 1,
'duration': '2h 1m 4s',
},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['complete_at'] = build['started_at'] + datetime.timedelta(
hours=2, minutes=1, seconds=4
)
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_verbose(self):
yield self.createGerritStatus(verbose=True)
build = yield self.insert_build_new()
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build started.',
'abstain': False,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 0,
'duration': 'pending',
},
)
self.setUpLogging()
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged("Sending Gerrit status for")
@defer.inlineCallbacks
def test_not_verbose(self):
yield self.createGerritStatus(verbose=False)
build = yield self.insert_build_new()
self._http.expect(
method='post',
ep='/a/changes/12/revisions/2/verify-status~verifications',
json={
'comment': 'Build started.',
'abstain': False,
'name': 'Builder0',
'reporter': 'buildbot',
'url': 'http://localhost:8080/#/builders/79/builds/0',
'value': 0,
'duration': 'pending',
},
)
self.setUpLogging()
self._http.quiet = True
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertWasQuiet()
@defer.inlineCallbacks
def test_format_duration(self):
yield self.createGerritStatus(verbose=False)
self.assertEqual(self.sp.formatDuration(datetime.timedelta(seconds=1)), "0m 1s")
self.assertEqual(self.sp.formatDuration(datetime.timedelta(hours=1, seconds=1)), "1h 0m 1s")
self.assertEqual(
self.sp.formatDuration(datetime.timedelta(days=1, seconds=1)), "1 day 0h 0m 1s"
)
self.assertEqual(
self.sp.formatDuration(datetime.timedelta(days=2, seconds=1)), "2 days 0h 0m 1s"
)
@defer.inlineCallbacks
def test_gerrit_changes(self):
yield self.createGerritStatus()
# from chdict:
change_props = {
'event.change.owner.email': '[email protected]',
'event.change.subject': 'fix 1234',
'event.change.project': 'pr',
'event.change.owner.name': 'Dustin',
'event.change.number': '4321',
'event.change.url': 'http://buildbot.net',
'event.change.branch': 'br',
'event.type': 'patchset-created',
'event.patchSet.revision': 'abcdef',
'event.patchSet.number': '12',
'event.source': 'GerritChangeSource',
}
props = Properties.fromDict({k: (v, 'change') for k, v in change_props.items()})
changes = self.sp.getGerritChanges(props)
self.assertEqual(changes, [{'change_id': '4321', 'revision_id': '12'}])
| 15,331 | Python | .py | 371 | 30.070081 | 100 | 0.560927 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,469 | test_mail.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_mail.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import base64
import copy
from email import charset
from unittest.mock import Mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.config import ConfigErrors
from buildbot.process import properties
from buildbot.process.properties import Interpolate
from buildbot.process.results import SUCCESS
from buildbot.reporters import mail
from buildbot.reporters import utils
from buildbot.reporters.generators.build import BuildStatusGenerator
from buildbot.reporters.mail import MailNotifier
from buildbot.reporters.message import MessageFormatter
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.reporter import ReporterTestMixin
from buildbot.util import bytes2unicode
from buildbot.util import ssl
class TestMailNotifier(ConfigErrorsMixin, TestReactorMixin, unittest.TestCase, ReporterTestMixin):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setupMailNotifier(self, *args, **kwargs):
mn = MailNotifier(*args, **kwargs)
yield mn.setServiceParent(self.master)
yield mn.startService()
return mn
@defer.inlineCallbacks
def test_change_name(self):
mn = yield self.setupMailNotifier('[email protected]', name="custom_name")
self.assertEqual(mn.name, "custom_name")
@defer.inlineCallbacks
def do_test_createEmail_cte(self, funnyChars, expEncoding):
build = yield self.insert_build_finished(SUCCESS)
yield utils.getDetailsForBuild(self.master, build, want_properties=True)
msgdict = create_msgdict(funnyChars)
mn = yield self.setupMailNotifier('[email protected]')
m = yield mn.createEmail(msgdict, 'project-name', SUCCESS, [build])
cte_lines = [
l for l in m.as_string().split("\n") if l.startswith('Content-Transfer-Encoding:')
]
self.assertEqual(
cte_lines, [f'Content-Transfer-Encoding: {expEncoding}'], repr(m.as_string())
)
def test_createEmail_message_content_transfer_encoding_7bit(self):
# buildbot.reporters.mail.ENCODING is 'utf8'
# On Python 3, the body_encoding for 'utf8' is base64.
# On Python 2, the body_encoding for 'utf8' is None.
# If the body_encoding is None, the email package
# will try to deduce the 'Content-Transfer-Encoding'
# by calling email.encoders.encode_7or8bit().
# If the foo.encode('ascii') works on the body, it
# is assumed '7bit'. If it fails, it is assumed '8bit'.
expEncoding = None
input_charset = charset.Charset(mail.ENCODING)
if input_charset.body_encoding == charset.BASE64:
expEncoding = 'base64'
elif input_charset.body_encoding is None:
expEncoding = '7bit'
return self.do_test_createEmail_cte("old fashioned ascii", expEncoding)
def test_createEmail_message_content_transfer_encoding_8bit(self):
# buildbot.reporters.mail.ENCODING is 'utf8'
# On Python 3, the body_encoding for 'utf8' is base64.
# On Python 2, the body_encoding for 'utf8' is None.
# If the body_encoding is None, the email package
# will try to deduce the 'Content-Transfer-Encoding'
# by calling email.encoders.encode_7or8bit().
# If the foo.encode('ascii') works on the body, it
expEncoding = None
input_charset = charset.Charset(mail.ENCODING)
if input_charset.body_encoding == charset.BASE64:
expEncoding = 'base64'
elif input_charset.body_encoding is None:
expEncoding = '8bit'
return self.do_test_createEmail_cte("\U0001f4a7", expEncoding)
@defer.inlineCallbacks
def test_createEmail_message_without_patch_and_log_contains_unicode(self):
build = yield self.insert_build_finished(SUCCESS)
msgdict = create_msgdict()
mn = yield self.setupMailNotifier('[email protected]')
m = yield mn.createEmail(msgdict, 'project-n\u00e5me', SUCCESS, [build])
try:
m.as_string()
except UnicodeEncodeError:
self.fail('Failed to call as_string() on email message.')
@defer.inlineCallbacks
def test_createEmail_extraHeaders_one_build(self):
build = yield self.insert_build_finished(SUCCESS)
build['properties']['hhh'] = ('vvv', 'fake')
msgdict = create_msgdict()
mn = yield self.setupMailNotifier(
'[email protected]', extraHeaders={"hhh": properties.Property('hhh')}
)
# add some Unicode to detect encoding problems
m = yield mn.createEmail(msgdict, 'project-n\u00e5me', SUCCESS, [build])
txt = m.as_string()
# note that the headers *are* rendered
self.assertIn('hhh: vvv', txt)
@defer.inlineCallbacks
def test_createEmail_extraHeaders_two_builds(self):
build = yield self.insert_build_finished(SUCCESS)
yield utils.getDetailsForBuild(self.master, build, want_properties=True)
builds = [build, copy.deepcopy(build)]
builds[1]['builder']['name'] = 'builder2'
msgdict = create_msgdict()
mn = yield self.setupMailNotifier('[email protected]', extraHeaders={"hhh": 'vvv'})
m = yield mn.createEmail(msgdict, 'project-n\u00e5me', SUCCESS, builds)
txt = m.as_string()
# note that the headers are *not* rendered
self.assertIn('hhh: vvv', txt)
@defer.inlineCallbacks
def test_createEmail_message_with_patch_and_log_containing_unicode(self):
build = yield self.insert_build_finished(SUCCESS)
msgdict = create_msgdict()
patches = [{'body': '\u00e5\u00e4\u00f6'}]
logs = yield self.master.data.get(("steps", 50, 'logs'))
for l in logs:
l['stepname'] = "fakestep"
l['content'] = yield self.master.data.get(("logs", l['logid'], 'contents'))
mn = yield self.setupMailNotifier(
'[email protected]',
generators=[
BuildStatusGenerator(message_formatter=MessageFormatter(want_logs_content=True))
],
)
m = yield mn.createEmail(msgdict, 'project-n\u00e5me', SUCCESS, [build], patches, logs)
try:
s = m.as_string()
# The default transfer encoding is base64 for utf-8 even when it could be represented
# accurately by quoted 7bit encoding. TODO: it is possible to override it,
# see https://bugs.python.org/issue12552
if "base64" not in s:
self.assertIn("Unicode log", s)
else: # b64encode and remove '=' padding (hence [:-1])
logStr = bytes2unicode(base64.b64encode(b"Unicode log")[:-1])
self.assertIn(logStr, s)
self.assertIn('Content-Disposition: attachment; filename="fakestep.stdio"', s)
except UnicodeEncodeError:
self.fail('Failed to call as_string() on email message.')
@defer.inlineCallbacks
def setupBuildMessage(self, want_logs_content=False, **generator_kwargs):
build = yield self.insert_build_finished(SUCCESS)
formatter = Mock(spec=MessageFormatter)
formatter.format_message_for_build.return_value = {
"body": "body",
"type": "text",
"subject": "subject",
"extra_info": None,
}
formatter.want_properties = False
formatter.want_steps = False
formatter.want_logs = False
formatter.want_logs_content = want_logs_content
generator = BuildStatusGenerator(message_formatter=formatter, **generator_kwargs)
mn = yield self.setupMailNotifier('[email protected]', generators=[generator])
mn.findInterrestedUsersEmails = Mock(spec=mn.findInterrestedUsersEmails)
mn.findInterrestedUsersEmails.return_value = "<recipients>"
mn.processRecipients = Mock(spec=mn.processRecipients)
mn.processRecipients.return_value = "<processedrecipients>"
mn.createEmail = Mock(spec=mn.createEmail)
mn.createEmail.return_value = "<email>"
mn.sendMail = Mock(spec=mn.sendMail)
yield mn._got_event(('builds', 10, 'finished'), build)
return (mn, build, formatter)
@defer.inlineCallbacks
def test_buildMessage(self):
mn, build, formatter = yield self.setupBuildMessage(mode=("passing",))
formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=False, mode=('passing',), users=['me@foo']
)
mn.findInterrestedUsersEmails.assert_called_with(['me@foo'])
mn.processRecipients.assert_called_with('<recipients>', '<email>')
mn.sendMail.assert_called_with('<email>', '<processedrecipients>')
self.assertEqual(mn.createEmail.call_count, 1)
@defer.inlineCallbacks
def do_test_sendToInterestedUsers(
self,
lookup=None,
extraRecipients=None,
sendToInterestedUsers=True,
exp_called_with=None,
exp_TO=None,
exp_CC=None,
):
if extraRecipients is None:
extraRecipients = []
_ = yield self.insert_build_finished(SUCCESS)
mn = yield self.setupMailNotifier(
'[email protected]',
lookup=lookup,
extraRecipients=extraRecipients,
sendToInterestedUsers=sendToInterestedUsers,
)
recipients = yield mn.findInterrestedUsersEmails(['Big Bob <[email protected]>', 'narrator'])
m = {'To': None, 'CC': None}
all_recipients = mn.processRecipients(recipients, m)
self.assertEqual(sorted(all_recipients), sorted(exp_called_with))
self.assertEqual(m['To'], exp_TO)
self.assertEqual(m['CC'], exp_CC)
def test_sendToInterestedUsers_lookup(self):
return self.do_test_sendToInterestedUsers(
lookup="example.org",
exp_called_with=['Big Bob <[email protected]>', '[email protected]'],
exp_TO='"=?utf-8?q?Big_Bob?=" <[email protected]>, [email protected]',
)
def test_buildMessage_sendToInterestedUsers_no_lookup(self):
return self.do_test_sendToInterestedUsers(
exp_called_with=['Big Bob <[email protected]>'],
exp_TO='"=?utf-8?q?Big_Bob?=" <[email protected]>',
)
def test_buildMessage_sendToInterestedUsers_extraRecipients(self):
return self.do_test_sendToInterestedUsers(
extraRecipients=["[email protected]"],
exp_called_with=['Big Bob <[email protected]>', '[email protected]'],
exp_TO='"=?utf-8?q?Big_Bob?=" <[email protected]>',
exp_CC="[email protected]",
)
def test_sendToInterestedUsers_False(self):
return self.do_test_sendToInterestedUsers(
extraRecipients=["[email protected]"],
sendToInterestedUsers=False,
exp_called_with=['[email protected]'],
exp_TO="[email protected]",
)
def test_valid_emails(self):
valid_emails = [
'[email protected]', # + comment in local part
'[email protected].', # root dot
'My Name <[email protected]>', # With full name
'<[email protected]>', # With <>
'My Name <[email protected].>', # With full name (root dot)
'[email protected]',
] # IDN TLD (.misr, Egypt)
# If any of these email addresses fail, the test fails by
# yield self.setupMailNotifier raising a ConfigErrors exception.
MailNotifier('[email protected]', extraRecipients=valid_emails)
def test_invalid_email(self):
for invalid in [
'@',
'foo',
'foo@',
'@example.com',
'foo@invalid',
'foobar@ex+ample.com', # + in domain part
# whitespace in local part
'foo [email protected]',
'Foo\nBar <[email protected]>', # newline in name
'[email protected]',
]: # empty label (..)
with self.assertRaises(ConfigErrors):
MailNotifier('[email protected]', extraRecipients=[invalid])
@defer.inlineCallbacks
def test_sendMail_real_name_addresses(self):
fakeSenderFactory = Mock()
fakeSenderFactory.side_effect = lambda *args, **kwargs: args[5].callback(True)
self.patch(mail, 'ESMTPSenderFactory', fakeSenderFactory)
self.patch(mail, 'reactor', Mock())
msg = Mock()
msg.as_string = Mock(return_value='<email>')
mn = yield self.setupMailNotifier('John Doe <[email protected]>')
yield mn.sendMail(msg, ['Jane Doe <[email protected]>'])
self.assertIsInstance(fakeSenderFactory.call_args, tuple)
self.assertTrue(len(fakeSenderFactory.call_args) > 0)
self.assertTrue(len(fakeSenderFactory.call_args[0]) > 3)
self.assertEqual(fakeSenderFactory.call_args[0][2], '[email protected]')
self.assertEqual(fakeSenderFactory.call_args[0][3], ['[email protected]'])
@defer.inlineCallbacks
def do_test_sendMessage(self, **mn_kwargs):
fakeSenderFactory = Mock()
fakeSenderFactory.side_effect = lambda *args, **kwargs: args[5].callback(True)
self.patch(mail, 'ESMTPSenderFactory', fakeSenderFactory)
build = yield self.insert_build_finished(SUCCESS)
formatter = Mock(spec=MessageFormatter)
formatter.format_message_for_build.return_value = {
"body": "body",
"type": "text",
"subject": "subject",
"extra_info": None,
}
formatter.want_properties = False
formatter.want_steps = False
formatter.want_logs = False
formatter.want_logs_content = False
generator = BuildStatusGenerator(message_formatter=formatter)
mn = yield self.setupMailNotifier('[email protected]', generators=[generator], **mn_kwargs)
mn.findInterrestedUsersEmails = Mock(spec=mn.findInterrestedUsersEmails)
mn.findInterrestedUsersEmails.return_value = list("<recipients>")
mn.processRecipients = Mock(spec=mn.processRecipients)
mn.processRecipients.return_value = list("<processedrecipients>")
mn.createEmail = Mock(spec=mn.createEmail)
mn.createEmail.return_value.as_string = Mock(return_value="<email>")
yield mn._got_event(('builds', 10, 'finished'), build)
return (mn, build)
@defer.inlineCallbacks
def test_sendMessageOverTcp(self):
fakereactor = Mock()
self.patch(mail, 'reactor', fakereactor)
yield self.do_test_sendMessage()
self.assertEqual(1, len(fakereactor.method_calls))
self.assertIn(('connectTCP', ('localhost', 25, None), {}), fakereactor.method_calls)
@defer.inlineCallbacks
def test_sendMessageWithInterpolatedConfig(self):
"""Test that the secrets parameters are properly interpolated at reconfig stage
Note: in the unit test, we don't test that it is interpolated with secret.
That would require setting up secret manager.
We just test that the interpolation works.
"""
fakereactor = Mock()
self.patch(mail, 'reactor', fakereactor)
mn, _ = yield self.do_test_sendMessage(
smtpUser=Interpolate("u$er"), smtpPassword=Interpolate("pa$$word")
)
self.assertEqual(mn.smtpUser, "u$er")
self.assertEqual(mn.smtpPassword, "pa$$word")
self.assertEqual(1, len(fakereactor.method_calls))
self.assertIn(('connectTCP', ('localhost', 25, None), {}), fakereactor.method_calls)
@ssl.skipUnless
@defer.inlineCallbacks
def test_sendMessageOverSsl(self):
fakereactor = Mock()
self.patch(mail, 'reactor', fakereactor)
yield self.do_test_sendMessage(useSmtps=True)
self.assertEqual(1, len(fakereactor.method_calls))
self.assertIn(
('connectSSL', ('localhost', 25, None, fakereactor.connectSSL.call_args[0][3]), {}),
fakereactor.method_calls,
)
@ssl.skipUnless
@defer.inlineCallbacks
def test_hostname_for_client_context_for_tcp_over_tls(self):
fakeSenderFactory = Mock()
fakeSenderFactory.side_effect = lambda *args, **kwargs: args[5].callback(True)
self.patch(mail, 'ESMTPSenderFactory', fakeSenderFactory)
fakereactor = Mock()
self.patch(mail, 'reactor', fakereactor)
msg = Mock()
msg.as_string = Mock(return_value='<email>')
mn = yield self.setupMailNotifier('John Doe <[email protected]>', useTls=True)
yield mn.sendMail(msg, ['Jane Doe <[email protected]>'])
self.assertEqual(mn.useTls, True)
self.assertEqual(1, len(fakereactor.method_calls))
self.assertIn(('connectTCP', ('localhost', 25, None), {}), fakereactor.method_calls)
self.assertEqual("localhost", fakeSenderFactory.call_args.kwargs.get("hostname"))
@ssl.skipUnless
@defer.inlineCallbacks
def test_hostname_for_client_context_for_tcp_over_tls_auth(self):
fakeSenderFactory = Mock()
fakeSenderFactory.side_effect = lambda *args, **kwargs: args[5].callback(True)
self.patch(mail, 'ESMTPSenderFactory', fakeSenderFactory)
fakereactor = Mock()
self.patch(mail, 'reactor', fakereactor)
msg = Mock()
msg.as_string = Mock(return_value='<email>')
mn = yield self.setupMailNotifier(
'John Doe <[email protected]>', smtpUser="u$er", smtpPassword="pa$$word", useTls=False
)
yield mn.sendMail(msg, ['Jane Doe <[email protected]>'])
self.assertEqual(mn.smtpUser, "u$er")
self.assertEqual(mn.smtpPassword, "pa$$word")
self.assertEqual(mn.useTls, False)
self.assertEqual(1, len(fakereactor.method_calls))
self.assertIn(('connectTCP', ('localhost', 25, None), {}), fakereactor.method_calls)
self.assertEqual("localhost", fakeSenderFactory.call_args.kwargs.get("hostname"))
@ssl.skipUnless
@defer.inlineCallbacks
def test_hostname_for_client_context_for_plan_tcp(self):
fakeSenderFactory = Mock()
fakeSenderFactory.side_effect = lambda *args, **kwargs: args[5].callback(True)
self.patch(mail, 'ESMTPSenderFactory', fakeSenderFactory)
fakereactor = Mock()
self.patch(mail, 'reactor', fakereactor)
msg = Mock()
msg.as_string = Mock(return_value='<email>')
mn = yield self.setupMailNotifier('John Doe <[email protected]>', useTls=False)
yield mn.sendMail(msg, ['Jane Doe <[email protected]>'])
self.assertEqual(mn.useTls, False)
self.assertEqual(1, len(fakereactor.method_calls))
self.assertIn(('connectTCP', ('localhost', 25, None), {}), fakereactor.method_calls)
self.assertEqual(None, fakeSenderFactory.call_args.kwargs.get("hostname"))
def create_msgdict(funny_chars='\u00e5\u00e4\u00f6'):
unibody = f'Unicode body with non-ascii ({funny_chars}).'
msg_dict = {
"body": unibody,
"subject": "testsubject",
"type": 'plain',
"extra_info": None,
}
return msg_dict
| 20,296 | Python | .py | 411 | 40.681265 | 100 | 0.661785 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,470 | test_generators_buildrequest.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_generators_buildrequest.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest.mock import Mock
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.builder import Builder
from buildbot.process.results import CANCELLED
from buildbot.reporters.generators.buildrequest import BuildRequestGenerator
from buildbot.test.fake import fakemaster
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.reporter import ReporterTestMixin
class TestBuildRequestGenerator(
ConfigErrorsMixin, TestReactorMixin, unittest.TestCase, ReporterTestMixin
):
all_messages = ('failing', 'passing', 'warnings', 'exception', 'cancelled')
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
builder = Mock(spec=Builder)
builder.master = self.master
self.master.botmaster.getBuilderById = Mock(return_value=builder)
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_reactor()
@parameterized.expand([
('tags', 'tag'),
('tags', 1),
('builders', 'builder'),
('builders', 1),
('schedulers', 'scheduler'),
('schedulers', 1),
('branches', 'branch'),
('branches', 1),
])
def test_list_params_check_raises(self, arg_name, arg_value):
kwargs = {arg_name: arg_value}
g = BuildRequestGenerator(**kwargs)
with self.assertRaisesConfigError('must be a list or None'):
g.check()
def setup_generator(self, message=None, **kwargs):
if message is None:
message = {
"body": "start body",
"type": "plain",
"subject": "start subject",
"extra_info": None,
}
g = BuildRequestGenerator(**kwargs)
g.formatter = Mock(spec=g.formatter)
g.formatter.want_logs_content = False
g.formatter.format_message_for_build.return_value = message
return g
@defer.inlineCallbacks
def test_build_message_start_no_result(self):
g = yield self.setup_generator()
buildrequest = yield self.insert_buildrequest_new()
buildset = yield self.get_inserted_buildset()
build = yield g.partial_build_dict(self.master, buildrequest)
report = yield g.buildrequest_message(self.master, build)
g.formatter.format_message_for_build.assert_called_with(
self.master, build, is_buildset=True, mode=self.all_messages, users=[]
)
self.assertEqual(
report,
{
'body': 'start body',
'subject': 'start subject',
'type': 'plain',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_build_message_add_patch(self):
g = yield self.setup_generator(add_patch=True)
buildrequest = yield self.insert_buildrequest_new(insert_patch=True)
build = yield g.partial_build_dict(self.master, buildrequest)
report = yield g.buildrequest_message(self.master, build)
patch_dict = {
'author': 'him@foo',
'body': b'hello, world',
'comment': 'foo',
'level': 3,
'patchid': 99,
'subdir': '/foo',
}
self.assertEqual(report['patches'], [patch_dict])
@defer.inlineCallbacks
def test_build_message_add_patch_no_patch(self):
g = yield self.setup_generator(add_patch=True)
buildrequest = yield self.insert_buildrequest_new(insert_patch=False)
build = yield g.partial_build_dict(self.master, buildrequest)
report = yield g.buildrequest_message(self.master, build)
self.assertEqual(report['patches'], [])
@defer.inlineCallbacks
def test_generate_new(self):
g = yield self.setup_generator(add_patch=True)
buildrequest = yield self.insert_buildrequest_new(insert_patch=False)
buildset = yield self.get_inserted_buildset()
build = yield g.partial_build_dict(self.master, buildrequest)
report = yield g.generate(self.master, None, ('buildrequests', 11, 'new'), buildrequest)
self.assertEqual(
report,
{
'body': 'start body',
'subject': 'start subject',
'type': 'plain',
"extra_info": None,
'results': None,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_generate_cancel(self):
self.maxDiff = None
g = yield self.setup_generator(add_patch=True)
buildrequest = yield self.insert_buildrequest_new(insert_patch=False)
buildset = yield self.get_inserted_buildset()
build = yield g.partial_build_dict(self.master, buildrequest)
report = yield g.generate(self.master, None, ('buildrequests', 11, 'cancel'), buildrequest)
build['complete'] = True
build['results'] = CANCELLED
self.assertEqual(
report,
{
'body': 'start body',
'subject': 'start subject',
'type': 'plain',
"extra_info": None,
'results': CANCELLED,
'builds': [build],
"buildset": buildset,
'users': [],
'patches': [],
'logs': [],
},
)
@defer.inlineCallbacks
def test_generate_none(self):
g = BuildRequestGenerator(builders=['not_existing_builder'])
buildrequest = yield self.insert_buildrequest_new()
report = yield g.generate(self.master, None, ('buildrequests', 11, 'new'), buildrequest)
self.assertIsNone(report, None)
| 7,001 | Python | .py | 168 | 32.25 | 99 | 0.617249 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,471 | test_irc.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_irc.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import platform
import sys
from unittest import mock
from twisted.application import internet
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.config import ConfigErrors
from buildbot.process.properties import Interpolate
from buildbot.process.results import ALL_RESULTS
from buildbot.process.results import SUCCESS
from buildbot.reporters import irc
from buildbot.reporters import words
from buildbot.test.unit.reporters.test_words import ContactMixin
from buildbot.test.util import config
from buildbot.util import service
class TestIrcContact(ContactMixin, unittest.TestCase): # type: ignore[misc]
channelClass = irc.IRCChannel
contactClass = irc.IRCContact
def patch_act(self):
self.actions = []
def act(msg):
self.actions.append(msg)
self.contact.act = act
@defer.inlineCallbacks
def test_op_required_authz(self):
self.bot.authz = self.bot.expand_authz({('mute', 'unmute'): [self.USER]})
self.bot.getChannelOps = lambda channel: ['channelop']
self.assertFalse((yield self.contact.op_required('mute')))
@defer.inlineCallbacks
def test_op_required_operator(self):
self.bot.getChannelOps = lambda channel: [self.USER]
self.assertFalse((yield self.contact.op_required('command')))
@defer.inlineCallbacks
def test_op_required_unauthorized(self):
self.bot.getChannelOps = lambda channel: ['channelop']
self.assertTrue((yield self.contact.op_required('command')))
@defer.inlineCallbacks
def test_command_mute(self):
self.bot.getChannelOps = lambda channel: [self.USER]
yield self.do_test_command('mute')
self.assertTrue(self.contact.channel.muted)
@defer.inlineCallbacks
def test_command_mute_unauthorized(self):
self.bot.getChannelOps = lambda channel: []
yield self.do_test_command('mute')
self.assertFalse(self.contact.channel.muted)
self.assertIn("blah, blah", self.sent[0])
@defer.inlineCallbacks
def test_command_unmute(self):
self.bot.getChannelOps = lambda channel: [self.USER]
self.contact.channel.muted = True
yield self.do_test_command('unmute')
self.assertFalse(self.contact.channel.muted)
@defer.inlineCallbacks
def test_command_unmute_unauthorized(self):
self.bot.getChannelOps = lambda channel: []
self.contact.channel.muted = True
yield self.do_test_command('unmute')
self.assertTrue(self.contact.channel.muted)
@defer.inlineCallbacks
def test_command_unmute_not_muted(self):
self.bot.getChannelOps = lambda channel: [self.USER]
yield self.do_test_command('unmute')
self.assertFalse(self.contact.channel.muted)
self.assertIn("No one had told me to be quiet", self.sent[0])
@defer.inlineCallbacks
def test_command_notify(self):
self.bot.getChannelOps = lambda channel: [self.USER]
self.assertNotIn('success', self.contact.channel.notify_events)
yield self.do_test_command('notify', 'on success')
self.assertIn('success', self.contact.channel.notify_events)
@defer.inlineCallbacks
def test_command_notify_unauthorized(self):
self.bot.getChannelOps = lambda channel: []
self.assertNotIn('success', self.contact.channel.notify_events)
yield self.do_test_command('notify', 'on success')
self.assertNotIn('success', self.contact.channel.notify_events)
@defer.inlineCallbacks
def test_command_destroy(self):
self.patch_act()
yield self.do_test_command('destroy', exp_usage=False)
self.assertEqual(self.actions, ['readies phasers'])
@defer.inlineCallbacks
def test_command_dance(self):
yield self.do_test_command('dance', clock_ticks=[1.0] * 10, exp_usage=False)
self.assertTrue(self.sent) # doesn't matter what it sent
@defer.inlineCallbacks
def test_command_hustle(self):
self.patch_act()
yield self.do_test_command('hustle', clock_ticks=[1.0] * 2, exp_usage=False)
self.assertEqual(self.actions, ['does the hustle'])
def test_send(self):
events = []
def groupChat(dest, msg):
events.append((dest, msg))
self.contact.bot.groupSend = groupChat
self.contact.send("unmuted")
self.contact.send("unmuted, unicode \N{SNOWMAN}")
self.contact.channel.muted = True
self.contact.send("muted")
self.assertEqual(
events,
[
('#buildbot', 'unmuted'),
('#buildbot', 'unmuted, unicode \u2603'),
],
)
def test_handleAction_ignored(self):
self.patch_act()
self.contact.handleAction('waves hi')
self.assertEqual(self.actions, [])
def test_handleAction_kick(self):
self.patch_act()
self.contact.handleAction('kicks nick')
self.assertEqual(self.actions, ['kicks back'])
def test_handleAction_stupid(self):
self.patch_act()
self.contact.handleAction('stupids nick')
self.assertEqual(self.actions, ['stupids me too'])
def test_act(self):
events = []
def groupDescribe(dest, msg):
events.append((dest, msg))
self.contact.bot.groupDescribe = groupDescribe
self.contact.act("unmuted")
self.contact.act("unmuted, unicode \N{SNOWMAN}")
self.contact.channel.muted = True
self.contact.act("muted")
self.assertEqual(
events,
[
('#buildbot', 'unmuted'),
('#buildbot', 'unmuted, unicode \u2603'),
],
)
class FakeContact(service.AsyncService):
def __init__(self, user, channel=None):
super().__init__()
self.user_id = user
self.channel = mock.Mock()
self.messages = []
self.actions = []
def handleMessage(self, message):
self.messages.append(message)
def handleAction(self, data):
self.actions.append(data)
class TestIrcStatusBot(unittest.TestCase):
def makeBot(self, *args, **kwargs):
if not args:
args = ('nick', 'pass', ['#ch'], [], False)
bot = irc.IrcStatusBot(*args, **kwargs)
bot.parent = mock.Mock()
bot.parent.master.db.state.getState = lambda *args, **kwargs: None
return bot
def test_groupDescribe(self):
b = self.makeBot()
b.describe = lambda d, m: events.append(('n', d, m))
events = []
b.groupDescribe('#chan', 'hi')
self.assertEqual(events, [('n', '#chan', 'hi')])
def test_groupChat(self):
b = self.makeBot()
b.msg = lambda d, m: events.append(('n', d, m))
events = []
b.groupSend('#chan', 'hi')
self.assertEqual(events, [('n', '#chan', 'hi')])
def test_groupChat_notice(self):
b = self.makeBot('nick', 'pass', ['#ch'], [], True)
b.notice = lambda d, m: events.append(('n', d, m))
events = []
b.groupSend('#chan', 'hi')
self.assertEqual(events, [('n', '#chan', 'hi')])
def test_msg(self):
b = self.makeBot()
b.msg = lambda d, m: events.append(('m', d, m))
events = []
b.msg('nick', 'hi')
self.assertEqual(events, [('m', 'nick', 'hi')])
def test_getContact(self):
b = self.makeBot()
c1 = b.getContact(user='u1', channel='c1')
c2 = b.getContact(user='u1', channel='c2')
c1b = b.getContact(user='u1', channel='c1')
self.assertIdentical(c1, c1b)
self.assertIsInstance(c2, words.Contact)
def test_getContact_case_insensitive(self):
b = self.makeBot()
c1 = b.getContact(user='u1')
c1b = b.getContact(user='U1')
self.assertIdentical(c1, c1b)
def test_getContact_invalid(self):
b = self.makeBot()
b.authz = {'': None}
u = b.getContact(user='u0', channel='c0')
self.assertNotIn(('c0', 'u0'), b.contacts)
self.assertNotIn('c0', b.channels)
if platform.python_implementation() != 'PyPy':
self.assertEqual(sys.getrefcount(u), 2) # local, sys
c = u.channel
self.assertEqual(sys.getrefcount(c), 3) # local, contact, sys
del u
self.assertEqual(sys.getrefcount(c), 2) # local, sys
def test_getContact_valid(self):
b = self.makeBot()
b.authz = {'': None, 'command': ['u0']}
b.getContact(user='u0', channel='c0')
self.assertIn(('c0', 'u0'), b.contacts)
def test_privmsg_user(self):
b = self.makeBot()
b.contactClass = FakeContact
b.privmsg('jimmy!~foo@bar', 'nick', 'hello')
c = b.getContact('jimmy')
self.assertEqual(c.messages, ['hello'])
def test_privmsg_user_uppercase(self):
b = self.makeBot('NICK', 'pass', ['#ch'], [], False)
b.contactClass = FakeContact
b.privmsg('jimmy!~foo@bar', 'NICK', 'hello')
c = b.getContact('jimmy')
self.assertEqual(c.messages, ['hello'])
def test_privmsg_channel_unrelated(self):
b = self.makeBot()
b.contactClass = FakeContact
b.privmsg('jimmy!~foo@bar', '#ch', 'hello')
c = b.getContact('jimmy', '#ch')
self.assertEqual(c.messages, [])
def test_privmsg_channel_related(self):
b = self.makeBot()
b.contactClass = FakeContact
b.privmsg('jimmy!~foo@bar', '#ch', 'nick: hello')
c = b.getContact('jimmy', '#ch')
self.assertEqual(c.messages, [' hello'])
def test_action_unrelated(self):
b = self.makeBot()
b.contactClass = FakeContact
b.action('jimmy!~foo@bar', '#ch', 'waves')
c = b.getContact('jimmy', '#ch')
self.assertEqual(c.actions, [])
def test_action_unrelated_buildbot(self):
b = self.makeBot()
b.contactClass = FakeContact
# b.nickname is not 'buildbot'
b.action('jimmy!~foo@bar', '#ch', 'waves at buildbot')
c = b.getContact('jimmy', '#ch')
self.assertEqual(c.actions, [])
def test_action_related(self):
b = self.makeBot()
b.contactClass = FakeContact
b.action('jimmy!~foo@bar', '#ch', 'waves at nick')
c = b.getContact('jimmy', '#ch')
self.assertEqual(c.actions, ['waves at nick'])
def test_signedOn(self):
b = self.makeBot(
'nick',
'pass',
['#ch1', {"channel": '#ch2', "password": 'sekrits'}],
['jimmy', 'bobby'],
False,
)
events = []
def msg(d, m):
events.append(('m', d, m))
b.msg = msg
def join(channel, key):
events.append(('k', channel, key))
b.join = join
b.contactClass = FakeContact
b.signedOn()
self.assertEqual(
sorted(events),
[
('k', '#ch1', None),
('k', '#ch2', 'sekrits'),
('m', 'Nickserv', 'IDENTIFY pass'),
],
)
self.assertEqual(
sorted(b.contacts.keys()),
# channels don't get added until joined() is called
sorted([('jimmy', 'jimmy'), ('bobby', 'bobby')]),
)
def test_register_SASL(self):
b = self.makeBot('nick', 'pass', ['#ch1'], ['jimmy'], False, useSASL=True)
events = []
def sendLine(line):
events.append(('l', line))
if line == "AUTHENTICATE PLAIN":
events.append(('s', "AUTHENTICATE"))
b.irc_AUTHENTICATE(None, None)
b.sendLine = sendLine
b.register("bot")
self.assertEqual(
events,
[
('l', 'CAP REQ :sasl'),
('l', 'NICK bot'),
('l', 'USER bot foo bar :None'),
('l', 'AUTHENTICATE PLAIN'),
('s', 'AUTHENTICATE'),
('l', 'AUTHENTICATE bmljawBuaWNrAHBhc3M='),
('l', 'CAP END'),
],
)
def test_register_legacy(self):
b = self.makeBot('nick', 'pass', ['#ch1'], ['jimmy'], False, useSASL=False)
events = []
def sendLine(line):
events.append(('l', line))
b.sendLine = sendLine
b.register("bot")
self.assertEqual(
events, [('l', 'PASS pass'), ('l', 'NICK bot'), ('l', 'USER bot foo bar :None')]
)
def test_joined(self):
b = self.makeBot()
b.joined('#ch1')
b.joined('#ch2')
self.assertEqual(sorted(b.channels.keys()), sorted(['#ch1', '#ch2']))
def test_userLeft_or_userKicked(self):
b = self.makeBot()
b.getContact(channel='c', user='u')
self.assertIn(('c', 'u'), b.contacts)
b.userKicked('u', 'c', 'k', 'm')
self.assertNotIn(('c', 'u'), b.contacts)
def test_userQuit(self):
b = self.makeBot()
b.getContact(channel='c1', user='u')
b.getContact(channel='c2', user='u')
b.getContact(user='u')
self.assertEqual(len(b.contacts), 3)
b.userQuit('u', 'm')
self.assertEqual(len(b.contacts), 0)
def test_other(self):
# these methods just log, but let's get them covered anyway
b = self.makeBot()
b.left('#ch1')
b.kickedFrom('#ch1', 'dustin', 'go away!')
def test_format_build_status(self):
b = self.makeBot()
self.assertEqual(b.format_build_status({'results': SUCCESS}), "completed successfully")
def test_format_build_status_short(self):
b = self.makeBot()
self.assertEqual(b.format_build_status({'results': SUCCESS}, True), ", Success")
def test_format_build_status_colors(self):
b = self.makeBot()
b.useColors = True
self.assertEqual(
b.format_build_status({'results': SUCCESS}), "\x033completed successfully\x0f"
)
colors_used = set()
status_texts = set()
for result in ALL_RESULTS:
status = b.format_build_status({'results': result})
self.assertTrue(status.startswith('\x03'))
self.assertTrue(status.endswith('\x0f'))
i = 0
for i, c in enumerate(status[1:-1], start=2):
if c.isnumeric():
continue
break
colors_used.add(status[1:i])
status_texts.add(status[i:-1])
self.assertEqual(len(colors_used), len(ALL_RESULTS))
self.assertEqual(len(status_texts), len(ALL_RESULTS))
def test_getNames(self):
b = self.makeBot()
b.sendLine = lambda *args: None
d = b.getNames('#channel')
names = []
def cb(n):
names.extend(n)
d.addCallback(cb)
b.irc_RPL_NAMREPLY('', ('test', '=', '#channel', 'user1 user2'))
b.irc_RPL_ENDOFNAMES('', ('test', '#channel'))
self.assertEqual(names, ['user1', 'user2'])
def test_getChannelOps(self):
b = self.makeBot()
b.sendLine = lambda *args: None
d = b.getChannelOps('#channel')
names = []
def cb(n):
names.extend(n)
d.addCallback(cb)
b.irc_RPL_NAMREPLY('', ('test', '=', '#channel', 'user1 @user2'))
b.irc_RPL_ENDOFNAMES('', ('test', '#channel'))
self.assertEqual(names, ['user2'])
class TestIrcStatusFactory(unittest.TestCase):
def makeFactory(self, *args, **kwargs):
if not args:
args = ('nick', 'pass', ['ch'], [], [], {}, {})
return irc.IrcStatusFactory(*args, **kwargs)
def test_shutdown(self):
# this is kinda lame, but the factory would be better tested
# in an integration-test environment
f = self.makeFactory()
self.assertFalse(f.shuttingDown)
f.shutdown()
self.assertTrue(f.shuttingDown)
class TestIRC(config.ConfigErrorsMixin, unittest.TestCase):
def makeIRC(self, **kwargs):
kwargs.setdefault('host', 'localhost')
kwargs.setdefault('nick', 'russo')
kwargs.setdefault('channels', ['#buildbot'])
self.factory = None
def TCPClient(host, port, factory):
client = mock.Mock(name='tcp-client')
client.host = host
client.port = port
client.factory = factory
# keep for later
self.factory = factory
self.client = client
return client
self.patch(internet, 'TCPClient', TCPClient)
return irc.IRC(**kwargs)
@defer.inlineCallbacks
def test_constr(self):
ircStatus = self.makeIRC(host='foo', port=123)
yield ircStatus.startService()
self.client.setServiceParent.assert_called_with(ircStatus)
self.assertEqual(self.client.host, 'foo')
self.assertEqual(self.client.port, 123)
self.assertIsInstance(self.client.factory, irc.IrcStatusFactory)
@defer.inlineCallbacks
def test_constr_args(self):
# test that the args to IRC(..) make it all the way down to
# the IrcStatusBot class
s = self.makeIRC(
host='host',
nick='nick',
channels=['channels'],
pm_to_nicks=['pm', 'to', 'nicks'],
noticeOnChannel=True,
port=1234,
tags=['tags'],
password=Interpolate('pass'),
notify_events={
'successToFailure': 1,
},
showBlameList=False,
useRevisions=True,
useSSL=False,
useSASL=False,
lostDelay=10,
failedDelay=20,
useColors=False,
)
yield s.startService()
# patch it up
factory = self.factory
proto_obj = mock.Mock(name='proto_obj')
factory.protocol = mock.Mock(name='protocol', return_value=proto_obj)
# run it
p = factory.buildProtocol('address')
self.assertIdentical(p, proto_obj)
factory.protocol.assert_called_with(
'nick',
'pass',
['channels'],
['pm', 'to', 'nicks'],
True,
{},
['tags'],
{'successToFailure': 1},
useColors=False,
useSASL=False,
useRevisions=True,
showBlameList=False,
)
def test_service(self):
irc = self.makeIRC()
# just put it through its paces
irc.startService()
return irc.stopService()
# deprecated
@defer.inlineCallbacks
def test_allowForce_allowShutdown(self):
s = self.makeIRC(
host='host', nick='nick', channels=['channels'], allowForce=True, allowShutdown=False
)
yield s.startService()
self.assertEqual(
words.StatusBot.expand_authz(s.authz), {'FORCE': True, 'STOP': True, 'SHUTDOWN': False}
)
# deprecated
def test_allowForce_with_authz(self):
with self.assertRaises(ConfigErrors):
self.makeIRC(
host='host',
nick='nick',
channels=['channels'],
allowForce=True,
authz={'force': [12345]},
)
# deprecated
def test_allowShutdown_with_authz(self):
with self.assertRaises(ConfigErrors):
self.makeIRC(
host='host',
nick='nick',
channels=['channels'],
allowForce=True,
authz={'': [12345]},
)
| 20,358 | Python | .py | 517 | 30.129594 | 99 | 0.587901 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,472 | test_http.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_http.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.properties import Interpolate
from buildbot.process.results import SUCCESS
from buildbot.reporters.http import HttpStatusPush
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.misc import BuildDictLookAlike
from buildbot.test.util.reporter import ReporterTestMixin
class TestHttpStatusPush(TestReactorMixin, unittest.TestCase, ReporterTestMixin, ConfigErrorsMixin):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
yield self.master.startService()
@defer.inlineCallbacks
def createReporter(self, auth=("username", "passwd"), headers=None, **kwargs):
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master, self, "serv", auth=auth, headers=headers, debug=None, verify=None
)
interpolated_auth = None
if auth is not None:
username, passwd = auth
passwd = Interpolate(passwd)
interpolated_auth = (username, passwd)
self.sp = HttpStatusPush("serv", auth=interpolated_auth, headers=headers, **kwargs)
yield self.sp.setServiceParent(self.master)
@defer.inlineCallbacks
def tearDown(self):
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_basic(self):
yield self.createReporter()
self._http.expect("post", "", json=BuildDictLookAlike(complete=False))
self._http.expect("post", "", json=BuildDictLookAlike(complete=True))
build = yield self.insert_build_new()
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_basic_noauth(self):
yield self.createReporter(auth=None)
self._http.expect("post", "", json=BuildDictLookAlike(complete=False))
self._http.expect("post", "", json=BuildDictLookAlike(complete=True))
build = yield self.insert_build_new()
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_header(self):
yield self.createReporter(headers={'Custom header': 'On'})
self._http.expect("post", "", json=BuildDictLookAlike())
build = yield self.insert_build_finished(SUCCESS)
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def http2XX(self, code, content):
yield self.createReporter()
self._http.expect('post', '', code=code, content=content, json=BuildDictLookAlike())
build = yield self.insert_build_finished(SUCCESS)
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_http200(self):
yield self.http2XX(code=200, content="OK")
@defer.inlineCallbacks
def test_http201(self): # e.g. GitHub returns 201
yield self.http2XX(code=201, content="Created")
@defer.inlineCallbacks
def test_http202(self):
yield self.http2XX(code=202, content="Accepted")
| 4,396 | Python | .py | 89 | 43.280899 | 100 | 0.715051 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,473 | test_gitlab.py | buildbot_buildbot/master/buildbot/test/unit/reporters/test_gitlab.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.builder import Builder
from buildbot.process.properties import Interpolate
from buildbot.process.results import CANCELLED
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.reporters.gitlab import HOSTED_BASE_URL
from buildbot.reporters.gitlab import GitLabStatusPush
from buildbot.test.fake import fakemaster
from buildbot.test.fake import httpclientservice as fakehttpclientservice
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.util import logging
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.reporter import ReporterTestMixin
class TestGitLabStatusPush(
TestReactorMixin, ConfigErrorsMixin, unittest.TestCase, ReporterTestMixin, logging.LoggingMixin
):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.setup_reporter_test()
# repository must be in the form http://gitlab/<owner>/<project>
self.reporter_test_repo = 'http://gitlab/buildbot/buildbot'
self.master = yield fakemaster.make_master(self, wantData=True, wantDb=True, wantMq=True)
yield self.master.startService()
self._http = yield fakehttpclientservice.HTTPClientService.getService(
self.master,
self,
HOSTED_BASE_URL,
headers={'PRIVATE-TOKEN': 'XXYYZZ'},
debug=None,
verify=None,
)
self.sp = GitLabStatusPush(Interpolate('XXYYZZ'))
yield self.sp.setServiceParent(self.master)
def setup_properties(props):
props.setProperty("buildername", "Builder0", "Builder")
return defer.succeed(None)
builder = mock.Mock(spec=Builder)
builder.master = self.master
builder.name = "Builder0"
builder.setup_properties = setup_properties
self.master.botmaster.getBuilderById = mock.Mock(return_value=builder)
@defer.inlineCallbacks
def tearDown(self):
yield self.master.stopService()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def test_buildrequest(self):
buildrequest = yield self.insert_buildrequest_new()
self._http.expect('get', '/api/v4/projects/buildbot%2Fbuildbot', content_json={"id": 1})
self._http.expect(
'post',
'/api/v4/projects/1/statuses/d34db33fd43db33f',
json={
'state': 'pending',
'target_url': 'http://localhost:8080/#/buildrequests/11',
'ref': 'master',
'description': 'Build pending.',
'name': 'buildbot/Builder0',
},
)
self._http.expect(
'post',
'/api/v4/projects/1/statuses/d34db33fd43db33f',
json={
'state': 'canceled',
'target_url': 'http://localhost:8080/#/buildrequests/11',
'ref': 'master',
'description': 'Build pending.',
'name': 'buildbot/Builder0',
},
)
yield self.sp._got_event(('buildrequests', 11, 'new'), buildrequest)
yield self.sp._got_event(('buildrequests', 11, 'cancel'), buildrequest)
@defer.inlineCallbacks
def test_basic(self):
build = yield self.insert_build_new()
self._http.expect('get', '/api/v4/projects/buildbot%2Fbuildbot', content_json={"id": 1})
self._http.expect(
'post',
'/api/v4/projects/1/statuses/d34db33fd43db33f',
json={
'state': 'running',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'master',
'description': 'Build started.',
'name': 'buildbot/Builder0',
},
)
self._http.expect(
'post',
'/api/v4/projects/1/statuses/d34db33fd43db33f',
json={
'state': 'success',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'master',
'description': 'Build done.',
'name': 'buildbot/Builder0',
},
)
self._http.expect(
'post',
'/api/v4/projects/1/statuses/d34db33fd43db33f',
json={
'state': 'failed',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'master',
'description': 'Build done.',
'name': 'buildbot/Builder0',
},
)
self._http.expect(
'post',
'/api/v4/projects/1/statuses/d34db33fd43db33f',
json={
'state': 'canceled',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'master',
'description': 'Build done.',
'name': 'buildbot/Builder0',
},
)
yield self.sp._got_event(('builds', 20, 'new'), build)
build['complete'] = True
build['results'] = SUCCESS
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = FAILURE
yield self.sp._got_event(('builds', 20, 'finished'), build)
build['results'] = CANCELLED
yield self.sp._got_event(('builds', 20, 'finished'), build)
@defer.inlineCallbacks
def test_sshurl(self):
self.reporter_test_repo = 'git@gitlab:buildbot/buildbot.git'
build = yield self.insert_build_new()
self._http.expect('get', '/api/v4/projects/buildbot%2Fbuildbot', content_json={"id": 1})
self._http.expect(
'post',
'/api/v4/projects/1/statuses/d34db33fd43db33f',
json={
'state': 'running',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'master',
'description': 'Build started.',
'name': 'buildbot/Builder0',
},
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
@defer.inlineCallbacks
def test_merge_request_forked(self):
self.reporter_test_repo = 'git@gitlab:buildbot/buildbot.git'
self.reporter_test_props['source_project_id'] = 20922342342
build = yield self.insert_build_new()
self._http.expect(
'post',
'/api/v4/projects/20922342342/statuses/d34db33fd43db33f',
json={
'state': 'running',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'master',
'description': 'Build started.',
'name': 'buildbot/Builder0',
},
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
# Don't run these tests in parallel!
del self.reporter_test_props['source_project_id']
@defer.inlineCallbacks
def test_noproject(self):
self.reporter_test_repo = 'git@gitlab:buildbot/buildbot.git'
self.setUpLogging()
build = yield self.insert_build_new()
self._http.expect(
'get',
'/api/v4/projects/buildbot%2Fbuildbot',
content_json={"message": 'project not found'},
code=404,
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged(
r"Unknown \(or hidden\) gitlab projectbuildbot%2Fbuildbot: project not found"
)
@defer.inlineCallbacks
def test_nourl(self):
self.reporter_test_repo = ''
build = yield self.insert_build_new()
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
# implicit check that no http request is done
# nothing is logged as well
@defer.inlineCallbacks
def test_senderror(self):
self.setUpLogging()
build = yield self.insert_build_new()
self._http.expect('get', '/api/v4/projects/buildbot%2Fbuildbot', content_json={"id": 1})
self._http.expect(
'post',
'/api/v4/projects/1/statuses/d34db33fd43db33f',
json={
'state': 'running',
'target_url': 'http://localhost:8080/#/builders/79/builds/0',
'ref': 'master',
'description': 'Build started.',
'name': 'buildbot/Builder0',
},
content_json={'message': 'sha1 not found for branch master'},
code=404,
)
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged(
"Could not send status \"running\" for"
" http://gitlab/buildbot/buildbot at d34db33fd43db33f:"
" sha1 not found for branch master"
)
@defer.inlineCallbacks
def test_badchange(self):
self.setUpLogging()
build = yield self.insert_build_new()
self._http.expect('get', '/api/v4/projects/buildbot%2Fbuildbot', content_json={"id": 1})
build['complete'] = False
yield self.sp._got_event(('builds', 20, 'new'), build)
self.assertLogged(
"Failed to send status \"running\" for"
" http://gitlab/buildbot/buildbot at d34db33fd43db33f\n"
"Traceback"
)
self.flushLoggedErrors(AssertionError)
| 10,354 | Python | .py | 247 | 31.82996 | 99 | 0.596173 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,474 | test_python_twisted.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_python_twisted.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import textwrap
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.properties import Property
from buildbot.process.results import FAILURE
from buildbot.process.results import SKIPPED
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.steps import python_twisted
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
failureLog = """\
buildbot.test.unit.test_steps_python_twisted.Trial.testProperties ... [FAILURE]
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_env ... [FAILURE]
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_env_nodupe ... [FAILURE]/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/fake/logfile.py:92: UserWarning: step uses removed LogFile method `getText`
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_env_supplement ... [FAILURE]/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/fake/logfile.py:92: UserWarning: step uses removed LogFile method `getText`
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_jobs ... [FAILURE]/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/fake/logfile.py:92: UserWarning: step uses removed LogFile method `getText`
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_jobsProperties ... [FAILURE]
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_plural ... [FAILURE]
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_singular ... [FAILURE]
===============================================================================
[FAIL]
Traceback (most recent call last):
File "/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/util/steps.py", line 244, in check
"expected step outcome")
File "/home/dustin/code/buildbot/t/buildbot/sandbox/lib/python2.7/site-packages/twisted/trial/_synctest.py", line 356, in assertEqual
% (msg, pformat(first), pformat(second)))
twisted.trial.unittest.FailTest: expected step outcome
not equal:
a = {'result': 3, 'status_text': ['2 tests', 'passed']}
b = {'result': 0, 'status_text': ['2 tests', 'passed']}
buildbot.test.unit.test_steps_python_twisted.Trial.testProperties
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_plural
===============================================================================
[FAIL]
Traceback (most recent call last):
File "/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/util/steps.py", line 244, in check
"expected step outcome")
File "/home/dustin/code/buildbot/t/buildbot/sandbox/lib/python2.7/site-packages/twisted/trial/_synctest.py", line 356, in assertEqual
% (msg, pformat(first), pformat(second)))
twisted.trial.unittest.FailTest: expected step outcome
not equal:
a = {'result': 3, 'status_text': ['no tests', 'run']}
b = {'result': 0, 'status_text': ['no tests', 'run']}
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_env
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_env_nodupe
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_env_supplement
===============================================================================
[FAIL]
Traceback (most recent call last):
File "/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/util/steps.py", line 244, in check
"expected step outcome")
File "/home/dustin/code/buildbot/t/buildbot/sandbox/lib/python2.7/site-packages/twisted/trial/_synctest.py", line 356, in assertEqual
% (msg, pformat(first), pformat(second)))
twisted.trial.unittest.FailTest: expected step outcome
not equal:
a = {'result': 3, 'status_text': ['1 test', 'passed']}
b = {'result': 0, 'status_text': ['1 test', 'passed']}
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_jobs
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_jobsProperties
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_singular
-------------------------------------------------------------------------------
Ran 8 tests in 0.101s
FAILED (failures=8)
"""
class Trial(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_run_env(self):
self.setup_step(
python_twisted.Trial(
workdir='build', tests='testname', testpath=None, env={'PYTHONPATH': 'somepath'}
)
)
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
env={"PYTHONPATH": 'somepath'},
)
.stdout("Ran 0 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='no tests run')
return self.run_step()
def test_run_env_supplement(self):
self.setup_step(
python_twisted.Trial(
workdir='build',
tests='testname',
testpath='path1',
env={'PYTHONPATH': ['path2', 'path3']},
)
)
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
env={"PYTHONPATH": ['path1', 'path2', 'path3']},
)
.stdout("Ran 0 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='no tests run')
return self.run_step()
def test_run_env_nodupe(self):
self.setup_step(
python_twisted.Trial(
workdir='build',
tests='testname',
testpath='path2',
env={'PYTHONPATH': ['path1', 'path2']},
)
)
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
env={"PYTHONPATH": ['path1', 'path2']},
)
.stdout("Ran 0 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='no tests run')
return self.run_step()
def test_run_singular(self):
self.setup_step(python_twisted.Trial(workdir='build', tests='testname', testpath=None))
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
)
.stdout("Ran 1 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='1 test passed')
return self.run_step()
def test_run_plural(self):
self.setup_step(python_twisted.Trial(workdir='build', tests='testname', testpath=None))
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
)
.stdout("Ran 2 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='2 tests passed')
return self.run_step()
def test_run_failure(self):
self.setup_step(python_twisted.Trial(workdir='build', tests='testname', testpath=None))
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
)
.stdout(failureLog)
.exit(1)
)
self.expect_outcome(result=FAILURE, state_string='tests 8 failures (failure)')
self.expect_log_file(
'problems', failureLog.split('\n\n', 1)[1][:-1] + '\nprogram finished with exit code 1'
)
self.expect_log_file(
'warnings',
textwrap.dedent("""\
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_env_nodupe ... [FAILURE]/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/fake/logfile.py:92: UserWarning: step uses removed LogFile method `getText`
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_env_supplement ... [FAILURE]/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/fake/logfile.py:92: UserWarning: step uses removed LogFile method `getText`
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_jobs ... [FAILURE]/home/dustin/code/buildbot/t/buildbot/master/buildbot/test/fake/logfile.py:92: UserWarning: step uses removed LogFile method `getText`
buildbot.test.unit.test_steps_python_twisted.Trial.test_run_jobsProperties ... [FAILURE]
"""),
)
return self.run_step()
def test_renderable_properties(self):
self.setup_step(
python_twisted.Trial(workdir='build', tests=Property('test_list'), testpath=None)
)
self.build.setProperty('test_list', ['testname'], 'Test')
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
)
.stdout("Ran 2 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='2 tests passed')
return self.run_step()
def test_build_changed_files(self):
self.setup_build(build_files=['my/test/file.py', 'my/test/file2.py'])
self.setup_step(
python_twisted.Trial(workdir='build', testChanges=True, testpath=None),
)
self.expect_commands(
ExpectShell(
workdir='build',
command=[
'trial',
'--reporter=bwverbose',
'--testmodule=my/test/file.py',
'--testmodule=my/test/file2.py',
],
logfiles={'test.log': '_trial_temp/test.log'},
)
.stdout("Ran 2 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='2 tests passed')
return self.run_step()
def test_test_path_env_python_path(self):
self.setup_step(
python_twisted.Trial(
workdir='build',
tests='testname',
testpath='custom/test/path',
env={'PYTHONPATH': '/existing/pypath'},
)
)
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
env={'PYTHONPATH': ['custom/test/path', '/existing/pypath']},
)
.stdout("Ran 2 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='2 tests passed')
return self.run_step()
def test_custom_reactor(self):
self.setup_step(
python_twisted.Trial(
workdir='build', reactor='customreactor', tests='testname', testpath=None
)
)
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', '--reactor=customreactor', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
)
.stdout("Ran 2 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='2 tests passed (custom)')
return self.run_step()
def test_custom_python(self):
self.setup_step(
python_twisted.Trial(
workdir='build', tests='testname', python='/bin/mypython', testpath=None
)
)
self.expect_commands(
ExpectShell(
workdir='build',
command=['/bin/mypython', 'trial', '--reporter=bwverbose', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
)
.stdout("Ran 2 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='2 tests passed')
return self.run_step()
def test_randomly(self):
self.setup_step(
python_twisted.Trial(workdir='build', randomly=True, tests='testname', testpath=None)
)
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', '--random=0', 'testname'],
logfiles={'test.log': '_trial_temp/test.log'},
)
.stdout("Ran 2 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='2 tests passed')
return self.run_step()
def test_run_jobs(self):
"""
The C{jobs} kwarg should correspond to trial's -j option (
included since Twisted 12.3.0), and make corresponding changes to
logfiles.
"""
self.setup_step(
python_twisted.Trial(workdir='build', tests='testname', testpath=None, jobs=2)
)
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', '--jobs=2', 'testname'],
logfiles={
'test.0.log': '_trial_temp/0/test.log',
'err.0.log': '_trial_temp/0/err.log',
'out.0.log': '_trial_temp/0/out.log',
'test.1.log': '_trial_temp/1/test.log',
'err.1.log': '_trial_temp/1/err.log',
'out.1.log': '_trial_temp/1/out.log',
},
)
.stdout("Ran 1 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='1 test passed')
return self.run_step()
def test_run_jobsProperties(self):
"""
C{jobs} should accept Properties
"""
self.setup_step(
python_twisted.Trial(
workdir='build', tests='testname', jobs=Property('jobs_count'), testpath=None
)
)
self.build.setProperty('jobs_count', '2', 'Test')
self.expect_commands(
ExpectShell(
workdir='build',
command=['trial', '--reporter=bwverbose', '--jobs=2', 'testname'],
logfiles={
'test.0.log': '_trial_temp/0/test.log',
'err.0.log': '_trial_temp/0/err.log',
'out.0.log': '_trial_temp/0/out.log',
'test.1.log': '_trial_temp/1/test.log',
'err.1.log': '_trial_temp/1/err.log',
'out.1.log': '_trial_temp/1/out.log',
},
)
.stdout("Ran 1 tests\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='1 test passed')
return self.run_step()
class HLint(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_run_ok(self):
self.setup_build(build_files=['foo.xhtml'])
self.setup_step(python_twisted.HLint(workdir='build'))
self.expect_commands(
ExpectShell(
workdir='build',
command=['bin/lore', '-p', '--output', 'lint', 'foo.xhtml'],
)
.stdout("dunno what hlint output looks like..\n")
.exit(0)
)
self.expect_log_file('files', 'foo.xhtml\n')
self.expect_outcome(result=SUCCESS, state_string='0 hlints')
return self.run_step()
def test_custom_python(self):
self.setup_build(build_files=['foo.xhtml'])
self.setup_step(python_twisted.HLint(workdir='build', python='/bin/mypython'))
self.expect_commands(
ExpectShell(
workdir='build',
command=['/bin/mypython', 'bin/lore', '-p', '--output', 'lint', 'foo.xhtml'],
).exit(0)
)
self.expect_log_file('files', 'foo.xhtml\n')
self.expect_outcome(result=SUCCESS, state_string='0 hlints')
return self.run_step()
def test_command_failure(self):
self.setup_build(build_files=['foo.xhtml'])
self.setup_step(python_twisted.HLint(workdir='build'))
self.expect_commands(
ExpectShell(
workdir='build',
command=['bin/lore', '-p', '--output', 'lint', 'foo.xhtml'],
).exit(1)
)
self.expect_log_file('files', 'foo.xhtml\n')
self.expect_outcome(result=FAILURE, state_string='hlint (failure)')
return self.run_step()
def test_no_build_files(self):
self.setup_step(python_twisted.HLint(workdir='build'))
self.expect_outcome(result=SKIPPED, state_string='hlint (skipped)')
return self.run_step()
def test_run_warnings(self):
self.setup_build(build_files=['foo.xhtml'])
self.setup_step(python_twisted.HLint(workdir='build'))
self.expect_commands(
ExpectShell(
workdir='build', command=['bin/lore', '-p', '--output', 'lint', 'foo.xhtml']
)
.stdout("colon: meaning warning\n")
.exit(0)
)
self.expect_log_file('warnings', 'colon: meaning warning')
self.expect_outcome(result=WARNINGS, state_string='1 hlint (warnings)')
return self.run_step()
class RemovePYCs(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_run_ok(self):
self.setup_step(python_twisted.RemovePYCs())
self.expect_commands(
ExpectShell(
workdir='wkdir',
command=['find', '.', '-name', '\'*.pyc\'', '-exec', 'rm', '{}', ';'],
).exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='remove .pycs')
return self.run_step()
| 19,764 | Python | .py | 442 | 34.599548 | 238 | 0.5901 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,475 | test_mswin.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_mswin.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.process.results import Results
from buildbot.steps import mswin
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
class TestRobocopySimple(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
"""
Test L{Robocopy} command building.
"""
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def _run_simple_test(
self,
source,
destination,
expected_args=None,
expected_code=0,
expected_res=SUCCESS,
**kwargs,
):
self.setup_step(mswin.Robocopy(source, destination, **kwargs))
self.get_nth_step(0).rendered = True
command = ['robocopy', source, destination]
if expected_args:
command += expected_args
command += ['/TEE', '/NP']
self.expect_commands(
ExpectShell(
workdir='wkdir',
command=command,
).exit(expected_code)
)
state_string = f"'robocopy {source} ...'"
if expected_res != SUCCESS:
state_string += f' ({Results[expected_res]})'
self.expect_outcome(result=expected_res, state_string=state_string)
return self.run_step()
def test_copy(self):
return self._run_simple_test(r'D:\source', r'E:\dest')
def test_copy_files(self):
return self._run_simple_test(
r'D:\source',
r'E:\dest',
files=['a.txt', 'b.txt', '*.log'],
expected_args=['a.txt', 'b.txt', '*.log'],
)
def test_copy_recursive(self):
return self._run_simple_test(r'D:\source', r'E:\dest', recursive=True, expected_args=['/E'])
def test_mirror_files(self):
return self._run_simple_test(
r'D:\source', r'E:\dest', files=['*.foo'], mirror=True, expected_args=['*.foo', '/MIR']
)
def test_move_files(self):
return self._run_simple_test(
r'D:\source', r'E:\dest', files=['*.foo'], move=True, expected_args=['*.foo', '/MOVE']
)
def test_exclude(self):
return self._run_simple_test(
r'D:\source',
r'E:\dest',
files=['blah*'],
exclude=['*.foo', '*.bar'],
expected_args=['blah*', '/XF', '*.foo', '*.bar'],
)
def test_exclude_files(self):
return self._run_simple_test(
r'D:\source',
r'E:\dest',
files=['blah*'],
exclude_files=['*.foo', '*.bar'],
expected_args=['blah*', '/XF', '*.foo', '*.bar'],
)
def test_exclude_dirs(self):
return self._run_simple_test(
r'D:\source',
r'E:\dest',
files=['blah*'],
exclude_dirs=['foo', 'bar'],
expected_args=['blah*', '/XD', 'foo', 'bar'],
)
def test_custom_opts(self):
return self._run_simple_test(
r'D:\source',
r'E:\dest',
files=['*.foo'],
custom_opts=['/R:10', '/W:60'],
expected_args=['*.foo', '/R:10', '/W:60'],
)
def test_verbose_output(self):
return self._run_simple_test(
r'D:\source',
r'E:\dest',
files=['*.foo'],
verbose=True,
expected_args=['*.foo', '/V', '/TS', '/FP'],
)
@parameterized.expand(
# Codes that mean uneventful copies (including no copy at all).
[(c, SUCCESS) for c in range(0, 2)]
# Codes that mean some mismatched or extra files were found.
+ [(c, WARNINGS) for c in range(2, 8)]
# Codes that mean errors have been encountered.
+ [(c, FAILURE) for c in range(8, 32)]
# bit 32 is meaningless
+ [(32, EXCEPTION)]
)
@defer.inlineCallbacks
def test_codes(self, code, expected_result):
yield self._run_simple_test(
r'D:\source', r'E:\dest', expected_code=code, expected_res=expected_result
)
| 5,248 | Python | .py | 137 | 30.211679 | 100 | 0.599882 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,476 | test_worker.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_worker.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import stat
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.interfaces import WorkerSetupError
from buildbot.process import buildstep
from buildbot.process import properties
from buildbot.process import remotetransfer
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.steps import worker
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import Expect
from buildbot.test.steps import ExpectCpdir
from buildbot.test.steps import ExpectDownloadFile
from buildbot.test.steps import ExpectGlob
from buildbot.test.steps import ExpectMkdir
from buildbot.test.steps import ExpectRemoteRef
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectRmfile
from buildbot.test.steps import ExpectStat
from buildbot.test.steps import ExpectUploadFile
from buildbot.test.steps import TestBuildStepMixin
class TestSetPropertiesFromEnv(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_simple(self):
self.setup_step(
worker.SetPropertiesFromEnv(
variables=["one", "two", "three", "five", "six"], source="me"
)
)
self.worker.worker_environ = {"one": "1", "two": None, "six": "6", "FIVE": "555"}
self.worker.worker_system = 'linux'
self.build.setProperty("four", 4, "them")
self.build.setProperty("five", 5, "them")
self.build.setProperty("six", 99, "them")
self.expect_outcome(result=SUCCESS, state_string="Set")
self.expect_property('one', "1", source='me')
self.expect_no_property('two')
self.expect_no_property('three')
self.expect_property('four', 4, source='them')
self.expect_property('five', 5, source='them')
self.expect_property('six', '6', source='me')
self.expect_log_file("properties", "one = '1'\nsix = '6'")
return self.run_step()
def test_case_folding(self):
self.setup_step(worker.SetPropertiesFromEnv(variables=["eNv"], source="me"))
self.worker.worker_environ = {"ENV": 'EE'}
self.worker.worker_system = 'win32'
self.expect_outcome(result=SUCCESS, state_string="Set")
self.expect_property('eNv', 'EE', source='me')
self.expect_log_file("properties", "eNv = 'EE'")
return self.run_step()
class TestFileExists(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_found(self):
self.setup_step(worker.FileExists(file="x"))
self.expect_commands(ExpectStat(file='x').stat_file().exit(0))
self.expect_outcome(result=SUCCESS, state_string="File found.")
return self.run_step()
def test_not_found(self):
self.setup_step(worker.FileExists(file="x"))
self.expect_commands(ExpectStat(file='x').stat(mode=0).exit(0))
self.expect_outcome(result=FAILURE, state_string="Not a file. (failure)")
return self.run_step()
def test_failure(self):
self.setup_step(worker.FileExists(file="x"))
self.expect_commands(ExpectStat(file='x').exit(1))
self.expect_outcome(result=FAILURE, state_string="File not found. (failure)")
return self.run_step()
def test_render(self):
self.setup_step(worker.FileExists(file=properties.Property("x")))
self.build.setProperty('x', 'XXX', 'here')
self.expect_commands(ExpectStat(file='XXX').exit(1))
self.expect_outcome(result=FAILURE, state_string="File not found. (failure)")
return self.run_step()
@defer.inlineCallbacks
def test_old_version(self):
self.setup_build(worker_version={})
self.setup_step(worker.FileExists(file="x"))
self.expect_outcome(result=EXCEPTION, state_string="finished (exception)")
yield self.run_step()
self.flushLoggedErrors(WorkerSetupError)
class TestCopyDirectory(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_success(self):
self.setup_step(worker.CopyDirectory(src="s", dest="d"))
self.expect_commands(ExpectCpdir(fromdir='s', todir='d', timeout=120).exit(0))
self.expect_outcome(result=SUCCESS, state_string="Copied s to d")
return self.run_step()
def test_timeout(self):
self.setup_step(worker.CopyDirectory(src="s", dest="d", timeout=300))
self.expect_commands(ExpectCpdir(fromdir='s', todir='d', timeout=300).exit(0))
self.expect_outcome(result=SUCCESS, state_string="Copied s to d")
return self.run_step()
def test_maxTime(self):
self.setup_step(worker.CopyDirectory(src="s", dest="d", maxTime=10))
self.expect_commands(ExpectCpdir(fromdir='s', todir='d', max_time=10, timeout=120).exit(0))
self.expect_outcome(result=SUCCESS, state_string="Copied s to d")
return self.run_step()
def test_failure(self):
self.setup_step(worker.CopyDirectory(src="s", dest="d"))
self.expect_commands(ExpectCpdir(fromdir='s', todir='d', timeout=120).exit(1))
self.expect_outcome(result=FAILURE, state_string="Copying s to d failed. (failure)")
return self.run_step()
def test_render(self):
self.setup_step(
worker.CopyDirectory(src=properties.Property("x"), dest=properties.Property("y"))
)
self.build.setProperty('x', 'XXX', 'here')
self.build.setProperty('y', 'YYY', 'here')
self.expect_commands(ExpectCpdir(fromdir='XXX', todir='YYY', timeout=120).exit(0))
self.expect_outcome(result=SUCCESS, state_string="Copied XXX to YYY")
return self.run_step()
class TestRemoveDirectory(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_success(self):
self.setup_step(worker.RemoveDirectory(dir="d"))
self.expect_commands(ExpectRmdir(dir='d').exit(0))
self.expect_outcome(result=SUCCESS, state_string="Deleted")
return self.run_step()
def test_failure(self):
self.setup_step(worker.RemoveDirectory(dir="d"))
self.expect_commands(ExpectRmdir(dir='d').exit(1))
self.expect_outcome(result=FAILURE, state_string="Delete failed. (failure)")
return self.run_step()
def test_render(self):
self.setup_step(worker.RemoveDirectory(dir=properties.Property("x")))
self.build.setProperty('x', 'XXX', 'here')
self.expect_commands(ExpectRmdir(dir='XXX').exit(0))
self.expect_outcome(result=SUCCESS, state_string="Deleted")
return self.run_step()
class TestMakeDirectory(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_success(self):
self.setup_step(worker.MakeDirectory(dir="d"))
self.expect_commands(ExpectMkdir(dir='d').exit(0))
self.expect_outcome(result=SUCCESS, state_string="Created")
return self.run_step()
def test_failure(self):
self.setup_step(worker.MakeDirectory(dir="d"))
self.expect_commands(ExpectMkdir(dir='d').exit(1))
self.expect_outcome(result=FAILURE, state_string="Create failed. (failure)")
return self.run_step()
def test_render(self):
self.setup_step(worker.MakeDirectory(dir=properties.Property("x")))
self.build.setProperty('x', 'XXX', 'here')
self.expect_commands(ExpectMkdir(dir='XXX').exit(0))
self.expect_outcome(result=SUCCESS, state_string="Created")
return self.run_step()
class CompositeUser(buildstep.BuildStep, worker.CompositeStepMixin):
def __init__(self, payload):
self.payload = payload
self.logEnviron = False
super().__init__()
@defer.inlineCallbacks
def run(self):
yield self.addLogForRemoteCommands('stdio')
res = yield self.payload(self)
return FAILURE if res else SUCCESS
class TestCompositeStepMixin(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_runRemoteCommand(self):
cmd_args = ('foo', {'bar': False})
def testFunc(x):
x.runRemoteCommand(*cmd_args)
self.setup_step(CompositeUser(testFunc))
self.expect_commands(Expect(*cmd_args).exit(0))
self.expect_outcome(result=SUCCESS)
def test_runRemoteCommandFail(self):
cmd_args = ('foo', {'bar': False})
@defer.inlineCallbacks
def testFunc(x):
yield x.runRemoteCommand(*cmd_args)
self.setup_step(CompositeUser(testFunc))
self.expect_commands(Expect(*cmd_args).exit(1))
self.expect_outcome(result=FAILURE)
return self.run_step()
@defer.inlineCallbacks
def test_runRemoteCommandFailNoAbandon(self):
cmd_args = ('foo', {'bar': False})
@defer.inlineCallbacks
def testFunc(x):
yield x.runRemoteCommand(*cmd_args, **{"abandonOnFailure": False})
testFunc.ran = True
self.setup_step(CompositeUser(testFunc))
self.expect_commands(Expect(*cmd_args).exit(1))
self.expect_outcome(result=SUCCESS)
yield self.run_step()
self.assertTrue(testFunc.ran)
def test_rmfile(self):
self.setup_step(CompositeUser(lambda x: x.runRmFile("d")))
self.expect_commands(ExpectRmfile(path='d', log_environ=False).exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mkdir(self):
self.setup_step(CompositeUser(lambda x: x.runMkdir("d")))
self.expect_commands(ExpectMkdir(dir='d', log_environ=False).exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_rmdir(self):
self.setup_step(CompositeUser(lambda x: x.runRmdir("d")))
self.expect_commands(ExpectRmdir(dir='d', log_environ=False).exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mkdir_fail(self):
self.setup_step(CompositeUser(lambda x: x.runMkdir("d")))
self.expect_commands(ExpectMkdir(dir='d', log_environ=False).exit(1))
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_glob(self):
@defer.inlineCallbacks
def testFunc(x):
res = yield x.runGlob("*.pyc")
self.assertEqual(res, ["one.pyc", "two.pyc"])
self.setup_step(CompositeUser(testFunc))
self.expect_commands(
ExpectGlob(path='*.pyc', log_environ=False).files(["one.pyc", "two.pyc"]).exit(0)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_glob_fail(self):
self.setup_step(CompositeUser(lambda x: x.runGlob("*.pyc")))
self.expect_commands(ExpectGlob(path='*.pyc', log_environ=False).exit(1))
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_abandonOnFailure(self):
@defer.inlineCallbacks
def testFunc(x):
yield x.runMkdir("d")
yield x.runMkdir("d")
self.setup_step(CompositeUser(testFunc))
self.expect_commands(ExpectMkdir(dir='d', log_environ=False).exit(1))
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_notAbandonOnFailure(self):
@defer.inlineCallbacks
def testFunc(x):
yield x.runMkdir("d", abandonOnFailure=False)
yield x.runMkdir("d", abandonOnFailure=False)
self.setup_step(CompositeUser(testFunc))
self.expect_commands(
ExpectMkdir(dir='d', log_environ=False).exit(1),
ExpectMkdir(dir='d', log_environ=False).exit(1),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_getFileContentFromWorker(self):
@defer.inlineCallbacks
def testFunc(x):
res = yield x.getFileContentFromWorker("file.txt")
self.assertEqual(res, "Hello world!")
self.setup_step(CompositeUser(testFunc))
self.expect_commands(
ExpectUploadFile(
workersrc="file.txt",
workdir='wkdir',
blocksize=32 * 1024,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string("Hello world!")
.exit(0)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_getFileContentFromWorker2_16(self):
@defer.inlineCallbacks
def testFunc(x):
res = yield x.getFileContentFromWorker("file.txt")
self.assertEqual(res, "Hello world!")
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(CompositeUser(testFunc))
self.expect_commands(
ExpectUploadFile(
slavesrc="file.txt",
workdir='wkdir',
blocksize=32 * 1024,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string("Hello world!")
.exit(0)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_downloadFileContentToWorker(self):
@defer.inlineCallbacks
def testFunc(x):
res = yield x.downloadFileContentToWorker("/path/dest1", "file text")
self.assertEqual(res, None)
self.setup_step(CompositeUser(testFunc))
self.expect_commands(
ExpectDownloadFile(
maxsize=None,
workdir='wkdir',
mode=None,
reader=ExpectRemoteRef(remotetransfer.FileReader),
blocksize=32768,
workerdest='/path/dest1',
)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_downloadFileContentToWorkerWithFilePermissions(self):
@defer.inlineCallbacks
def testFunc(x):
res = yield x.downloadFileContentToWorker("/path/dest1", "file text", mode=stat.S_IRUSR)
self.assertEqual(res, None)
self.setup_step(CompositeUser(testFunc))
self.expect_commands(
ExpectDownloadFile(
maxsize=None,
workdir='wkdir',
mode=stat.S_IRUSR,
reader=ExpectRemoteRef(remotetransfer.FileReader),
blocksize=32768,
workerdest='/path/dest1',
)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
| 16,813 | Python | .py | 372 | 36.674731 | 100 | 0.661597 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,477 | test_package_rpm_rpmbuild.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_package_rpm_rpmbuild.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from collections import OrderedDict
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process.properties import Interpolate
from buildbot.process.results import SUCCESS
from buildbot.steps.package.rpm import rpmbuild
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
class RpmBuild(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_no_specfile(self):
with self.assertRaises(config.ConfigErrors):
rpmbuild.RpmBuild()
def test_success(self):
self.setup_step(rpmbuild.RpmBuild(specfile="foo.spec", dist=".el5"))
self.expect_commands(
ExpectShell(
workdir='wkdir',
command='rpmbuild --define "_topdir '
'`pwd`" --define "_builddir `pwd`" --define "_rpmdir '
'`pwd`" --define "_sourcedir `pwd`" --define "_specdir '
'`pwd`" --define "_srcrpmdir `pwd`" --define "dist .el5" '
'-ba foo.spec',
)
.stdout('lalala')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='RPMBUILD')
return self.run_step()
@mock.patch('builtins.open', mock.mock_open())
def test_autoRelease(self):
self.setup_step(rpmbuild.RpmBuild(specfile="foo.spec", autoRelease=True))
self.expect_commands(
ExpectShell(
workdir='wkdir',
command='rpmbuild --define "_topdir '
'`pwd`" --define "_builddir `pwd`" --define "_rpmdir `pwd`" '
'--define "_sourcedir `pwd`" --define "_specdir `pwd`" '
'--define "_srcrpmdir `pwd`" --define "_release 0" '
'--define "dist .el6" -ba foo.spec',
)
.stdout('Your code has been rated at 10/10')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='RPMBUILD')
return self.run_step()
def test_define(self):
defines = [("a", "1"), ("b", "2")]
self.setup_step(rpmbuild.RpmBuild(specfile="foo.spec", define=OrderedDict(defines)))
self.expect_commands(
ExpectShell(
workdir='wkdir',
command='rpmbuild --define "_topdir '
'`pwd`" --define "_builddir `pwd`" --define "_rpmdir '
'`pwd`" --define "_sourcedir `pwd`" --define '
'"_specdir `pwd`" --define "_srcrpmdir `pwd`" '
'--define "a 1" --define "b 2" --define "dist .el6" '
'-ba foo.spec',
)
.stdout('Your code has been rated at 10/10')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='RPMBUILD')
return self.run_step()
def test_define_none(self):
self.setup_step(rpmbuild.RpmBuild(specfile="foo.spec", define=None))
self.expect_commands(
ExpectShell(
workdir='wkdir',
command='rpmbuild --define "_topdir '
'`pwd`" --define "_builddir `pwd`" --define "_rpmdir '
'`pwd`" --define "_sourcedir `pwd`" --define '
'"_specdir `pwd`" --define "_srcrpmdir `pwd`" '
'--define "dist .el6" -ba foo.spec',
)
.stdout('Your code has been rated at 10/10')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='RPMBUILD')
return self.run_step()
@defer.inlineCallbacks
def test_renderable_dist(self):
self.setup_step(
rpmbuild.RpmBuild(specfile="foo.spec", dist=Interpolate('%(prop:renderable_dist)s'))
)
self.build.setProperty('renderable_dist', '.el7', 'test')
self.expect_commands(
ExpectShell(
workdir='wkdir',
command='rpmbuild --define "_topdir '
'`pwd`" --define "_builddir `pwd`" --define "_rpmdir '
'`pwd`" --define "_sourcedir `pwd`" --define "_specdir '
'`pwd`" --define "_srcrpmdir `pwd`" --define "dist .el7" '
'-ba foo.spec',
)
.stdout('lalala')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='RPMBUILD')
yield self.run_step()
| 5,413 | Python | .py | 123 | 34.227642 | 96 | 0.597196 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,478 | test_source_p4.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_p4.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
# Portions Copyright 2013 Bad Dog Consulting
import platform
import textwrap
from twisted.internet import defer
from twisted.internet import error
from twisted.python import reflect
from twisted.trial import unittest
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.steps.source.p4 import P4
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.util import sourcesteps
from buildbot.test.util.config import ConfigErrorsMixin
from buildbot.test.util.properties import ConstantRenderable
_is_windows = platform.system() == 'Windows'
class TestP4(sourcesteps.SourceStepMixin, TestReactorMixin, ConfigErrorsMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setUpSourceStep()
@defer.inlineCallbacks
def tearDown(self):
yield self.tearDownSourceStep()
yield self.tear_down_test_reactor()
def setup_step(self, step, args=None, patch=None, **kwargs):
if args is None:
args = {}
step = super().setup_step(step, args={}, patch=None, **kwargs)
self.build.getSourceStamp().revision = args.get('revision', None)
# builddir property used to create absolute path required in perforce
# client spec.
workspace_dir = '/home/user/workspace'
if _is_windows:
workspace_dir = r'C:\Users\username\Workspace'
self.build.path_module = reflect.namedModule("ntpath")
self.build.setProperty('builddir', workspace_dir, 'P4')
def test_no_empty_step_config(self):
with self.assertRaisesConfigError('You must provide p4base or p4viewspec'):
P4()
def test_p4base_has_whitespace(self):
with self.assertRaisesConfigError(
'p4base should not end with a trailing / [p4base = //depot with space/]'
):
P4(p4base='//depot with space/')
def test_p4branch_has_whitespace(self):
with self.assertRaisesConfigError(
'p4base should not end with a trailing / [p4base = //depot/]'
):
P4(p4base='//depot/', p4branch='branch with space')
def test_no_p4base_has_leading_slash_step_config(self):
with self.assertRaisesConfigError('p4base should start with // [p4base = depot/]'):
P4(p4base='depot/')
def test_no_multiple_type_step_config(self):
with self.assertRaisesConfigError(
'Either provide p4viewspec or p4base and p4branch (and optionally p4extra_views)'
):
P4(
p4viewspec=('//depot/trunk', ''),
p4base='//depot',
p4branch='trunk',
p4extra_views=['src', 'doc'],
)
def test_no_p4viewspec_is_string_step_config(self):
with self.assertRaisesConfigError(
'p4viewspec must not be a string, and should be a sequence of 2 element sequences'
):
P4(p4viewspec='a_bad_idea')
def test_no_p4base_has_trailing_slash_step_config(self):
with self.assertRaisesConfigError(
'p4base should not end with a trailing / [p4base = //depot/]'
):
P4(p4base='//depot/')
def test_no_p4branch_has_trailing_slash_step_config(self):
with self.assertRaisesConfigError(
'p4branch should not end with a trailing / [p4branch = blah/]'
):
P4(p4base='//depot', p4branch='blah/')
def test_no_p4branch_with_no_p4base_step_config(self):
with self.assertRaisesConfigError('You must provide p4base or p4viewspec'):
P4(p4branch='blah')
def test_no_p4extra_views_with_no_p4base_step_config(self):
with self.assertRaisesConfigError('You must provide p4base or p4viewspec'):
P4(p4extra_views='blah')
def test_incorrect_mode(self):
with self.assertRaisesConfigError(
"mode invalid is not an IRenderable, or one of ('incremental', 'full')"
):
P4(p4base='//depot', mode='invalid')
def test_mode_incremental_p4base_with_revision(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
),
{"revision": '101'},
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self.expect_commands(
ExpectShell(
workdir='wkdir', # defaults to this, only changes if it has a copy mode.
command=['p4', '-V'],
).exit(0), # expected remote command # expected exit status
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'client',
'-i',
],
initial_stdin=client_spec,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'-ztag',
'changes',
'-m1',
'//p4_client1/...@101',
],
)
.stdout("... change 100")
.exit(0),
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'sync',
'//p4_client1/...@100',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'P4')
return self.run_step()
def _incremental(self, client_stdin='', extra_args=None, workdir='wkdir', timeout=20 * 60):
if extra_args is None:
extra_args = []
self.expect_commands(
ExpectShell(workdir=workdir, command=['p4', '-V']).exit( # expected remote command
0
), # expected exit status
ExpectShell(
workdir=workdir,
timeout=timeout,
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'client',
'-i',
],
initial_stdin=client_stdin,
).exit(0),
ExpectShell(
workdir=workdir,
timeout=timeout,
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'-ztag',
'changes',
'-m1',
'//p4_client1/...#head',
],
)
.stdout("... change 100")
.exit(0),
ExpectShell(
workdir=workdir,
timeout=timeout,
command=([
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
*extra_args,
'sync',
'//p4_client1/...@100',
]),
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'P4')
return self.run_step()
def test_mode_incremental_p4base(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._incremental(client_stdin=client_spec)
def test_mode_incremental_p4base_with_no_branch(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot/trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._incremental(client_stdin=client_spec)
def test_mode_incremental_p4base_with_p4extra_views(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4extra_views=[
('-//depot/trunk/test', 'test'),
('-//depot/trunk/doc', 'doc'),
('-//depot/trunk/white space', 'white space'),
],
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
\t-//depot/trunk/test/... //p4_client1/test/...
\t-//depot/trunk/doc/... //p4_client1/doc/...
\t"-//depot/trunk/white space/..." "//p4_client1/white space/..."
""")
self._incremental(client_stdin=client_spec)
def test_mode_incremental_p4viewspec(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4viewspec=[
('//depot/trunk/', ''),
('//depot/white space/', 'white space/'),
('-//depot/white space/excluded/', 'white space/excluded/'),
],
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
\t"//depot/white space/..." "//p4_client1/white space/..."
\t"-//depot/white space/excluded/..." "//p4_client1/white space/excluded/..."
""")
self._incremental(client_stdin=client_spec)
def test_mode_incremental_p4viewspec_suffix(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4viewspec_suffix=None,
p4viewspec=[
('//depot/trunk/foo.xml', 'bar.xml'),
('//depot/white space/...', 'white space/...'),
('-//depot/white space/excluded/...', 'white space/excluded/...'),
],
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/foo.xml //p4_client1/bar.xml
\t"//depot/white space/..." "//p4_client1/white space/..."
\t"-//depot/white space/excluded/..." "//p4_client1/white space/excluded/..."
""")
self._incremental(client_stdin=client_spec)
def test_mode_incremental_p4client_spec_options(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4client_spec_options='rmdir compress',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\trmdir compress
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._incremental(client_stdin=client_spec)
def test_mode_incremental_parent_workdir(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
workdir='../another_wkdir',
)
)
root_dir = '/home/user/another_wkdir'
if _is_windows:
root_dir = r'C:\Users\username\another_wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._incremental(client_stdin=client_spec, workdir='../another_wkdir')
def test_mode_incremental_p4extra_args(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
p4extra_args=['-Zproxyload'],
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._incremental(client_stdin=client_spec, extra_args=['-Zproxyload'])
def test_mode_incremental_timeout(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
timeout=60 * 60,
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._incremental(client_stdin=client_spec, timeout=60 * 60)
def test_mode_incremental_stream(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
stream=True,
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
Stream:\t//depot/trunk
""")
self._incremental(client_stdin=client_spec)
def _full(
self,
client_stdin='',
p4client='p4_client1',
p4user='user',
workdir='wkdir',
extra_args=None,
obfuscated_pass=True,
):
if extra_args is None:
extra_args = []
if obfuscated_pass:
expected_pass = ('obfuscated', 'pass', 'XXXXXX')
else:
expected_pass = 'pass'
self.expect_commands(
ExpectShell(workdir=workdir, command=['p4', '-V']).exit( # expected remote command
0
), # expected exit status
ExpectShell(
workdir=workdir,
command=[
'p4',
'-p',
'localhost:12000',
'-u',
p4user,
'-P',
expected_pass,
'-c',
p4client,
'client',
'-i',
],
initial_stdin=client_stdin,
).exit(0),
ExpectShell(
workdir=workdir,
command=[
'p4',
'-p',
'localhost:12000',
'-u',
p4user,
'-P',
expected_pass,
'-c',
p4client,
'-ztag',
'changes',
'-m1',
f'//{p4client}/...#head',
],
)
.stdout("... change 100")
.exit(0),
ExpectShell(
workdir=workdir,
command=[
'p4',
'-p',
'localhost:12000',
'-u',
p4user,
'-P',
expected_pass,
'-c',
p4client,
*extra_args,
'sync',
'#none',
],
).exit(0),
ExpectRmdir(dir=workdir, log_environ=True).exit(0),
ExpectShell(
workdir=workdir,
command=[
'p4',
'-p',
'localhost:12000',
'-u',
p4user,
'-P',
expected_pass,
'-c',
p4client,
*extra_args,
'sync',
f'//{p4client}/...@100',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'P4')
return self.run_step()
def test_mode_full_p4base(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_stdin = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...\n""")
self._full(client_stdin=client_stdin)
def test_mode_full_p4base_not_obfuscated(self):
self.setup_build(worker_version={'*': '2.15'})
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_stdin = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...\n""")
self._full(client_stdin=client_stdin, obfuscated_pass=False)
def test_mode_full_p4base_with_no_branch(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot/trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._full(client_stdin=client_spec)
def test_mode_full_p4viewspec(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4viewspec=[
('//depot/main/', ''),
('//depot/main/white space/', 'white space/'),
('-//depot/main/white space/excluded/', 'white space/excluded/'),
],
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_stdin = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/main/... //p4_client1/...
\t"//depot/main/white space/..." "//p4_client1/white space/..."
\t"-//depot/main/white space/excluded/..." "//p4_client1/white space/excluded/..."
""")
self._full(client_stdin=client_stdin)
def test_mode_full_renderable_p4base(self):
# Note that the config check skips checking p4base if it's a renderable
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base=ConstantRenderable('//depot'),
p4branch='release/1.0',
p4user='user',
p4client='p4_client2',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_stdin = textwrap.dedent(f"""\
Client: p4_client2
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/release/1.0/... //p4_client2/...\n""")
self._full(client_stdin=client_stdin, p4client='p4_client2')
def test_mode_full_renderable_p4client(self):
# Note that the config check skips checking p4base if it's a renderable
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client=ConstantRenderable('p4_client_render'),
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_stdin = textwrap.dedent(f"""\
Client: p4_client_render
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client_render/...\n""")
self._full(client_stdin=client_stdin, p4client='p4_client_render')
def test_mode_full_renderable_p4branch(self):
# Note that the config check skips checking p4base if it's a renderable
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch=ConstantRenderable('render_branch'),
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_stdin = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/render_branch/... //p4_client1/...\n""")
self._full(client_stdin=client_stdin)
def test_mode_full_renderable_p4viewspec(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4viewspec=[(ConstantRenderable('//depot/render_trunk/'), '')],
p4user='different_user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_stdin = textwrap.dedent(f"""\
Client: p4_client1
Owner: different_user
Description:
\tCreated by different_user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/render_trunk/... //p4_client1/...\n""")
self._full(client_stdin=client_stdin, p4user='different_user')
def test_mode_full_p4viewspec_suffix(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4viewspec_suffix=None,
p4viewspec=[
('//depot/trunk/foo.xml', 'bar.xml'),
('//depot/trunk/white space/...', 'white space/...'),
('-//depot/trunk/white space/excluded/...', 'white space/excluded/...'),
],
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/foo.xml //p4_client1/bar.xml
\t"//depot/trunk/white space/..." "//p4_client1/white space/..."
\t"-//depot/trunk/white space/excluded/..." "//p4_client1/white space/excluded/..."
""")
self._full(client_stdin=client_spec)
def test_mode_full_p4client_spec_options(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch='trunk',
p4client_spec_options='rmdir compress',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\trmdir compress
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._full(client_stdin=client_spec)
def test_mode_full_parent_workdir(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
workdir='../another_wkdir',
)
)
root_dir = '/home/user/another_wkdir'
if _is_windows:
root_dir = r'C:\Users\username\another_wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._full(client_stdin=client_spec, workdir='../another_wkdir')
def test_mode_full_p4extra_args(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
p4extra_args=['-Zproxyload'],
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self._full(client_stdin=client_spec, extra_args=['-Zproxyload'])
def test_mode_full_stream(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
stream=True,
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
Stream:\t//depot/trunk
""")
self._full(client_stdin=client_spec)
def test_mode_full_stream_renderable_p4base(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base=ConstantRenderable('//depot'),
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
stream=True,
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
Stream:\t//depot/trunk
""")
self._full(client_stdin=client_spec)
def test_mode_full_stream_renderable_p4branch(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='full',
p4base='//depot',
p4branch=ConstantRenderable('render_branch'),
p4user='user',
p4client='p4_client1',
p4passwd='pass',
stream=True,
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
Stream:\t//depot/render_branch
""")
self._full(client_stdin=client_spec)
def test_worker_connection_lost(self):
self.setup_step(
P4(
p4port='localhost:12000',
mode='incremental',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
),
{"revision": '100'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['p4', '-V']).error(error.ConnectionLost())
)
self.expect_outcome(result=RETRY, state_string="update (retry)")
return self.run_step()
def test_ticket_auth(self):
self.setup_step(
P4(
p4port='localhost:12000',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
use_tickets=True,
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
View:
\t//depot/trunk/... //p4_client1/...
""")
self.expect_commands(
ExpectShell(workdir='wkdir', command=['p4', '-V']).exit(0),
# This is the extra step that gets run when using tickets,
# and the password is not passed anymore after that.
ExpectShell(
workdir='wkdir',
command=['p4', '-p', 'localhost:12000', '-u', 'user', '-c', 'p4_client1', 'login'],
initial_stdin='pass\n',
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-c',
'p4_client1',
'client',
'-i',
],
initial_stdin=client_spec,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-c',
'p4_client1',
'-ztag',
'changes',
'-m1',
'//p4_client1/...#head',
],
)
.stdout("... change 100")
.exit(0),
ExpectShell(
workdir='wkdir',
command=([
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-c',
'p4_client1',
'sync',
'//p4_client1/...@100',
]),
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_client_type_readonly(self):
self.setup_step(
P4(
p4port='localhost:12000',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
p4client_type='readonly',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
Type:\treadonly
View:
\t//depot/trunk/... //p4_client1/...
""")
self.expect_commands(
ExpectShell(workdir='wkdir', command=['p4', '-V']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'client',
'-i',
],
initial_stdin=client_spec,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'-ztag',
'changes',
'-m1',
'//p4_client1/...#head',
],
)
.stdout("... change 100")
.exit(0),
ExpectShell(
workdir='wkdir',
command=([
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'sync',
'//p4_client1/...@100',
]),
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_client_type_partitioned(self):
self.setup_step(
P4(
p4port='localhost:12000',
p4base='//depot',
p4branch='trunk',
p4user='user',
p4client='p4_client1',
p4passwd='pass',
p4client_type='partitioned',
)
)
root_dir = '/home/user/workspace/wkdir'
if _is_windows:
root_dir = r'C:\Users\username\Workspace\wkdir'
client_spec = textwrap.dedent(f"""\
Client: p4_client1
Owner: user
Description:
\tCreated by user
Root:\t{root_dir}
Options:\tallwrite rmdir
LineEnd:\tlocal
Type:\tpartitioned
View:
\t//depot/trunk/... //p4_client1/...
""")
self.expect_commands(
ExpectShell(workdir='wkdir', command=['p4', '-V']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'client',
'-i',
],
initial_stdin=client_spec,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'-ztag',
'changes',
'-m1',
'//p4_client1/...#head',
],
)
.stdout("... change 100")
.exit(0),
ExpectShell(
workdir='wkdir',
command=([
'p4',
'-p',
'localhost:12000',
'-u',
'user',
'-P',
('obfuscated', 'pass', 'XXXXXX'),
'-c',
'p4_client1',
'sync',
'//p4_client1/...@100',
]),
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
| 45,055 | Python | .py | 1,335 | 20.453184 | 99 | 0.463904 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,479 | test_transfer.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_transfer.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import json
import os
import shutil
import tempfile
from unittest.mock import Mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process import remotetransfer
from buildbot.process.properties import Interpolate
from buildbot.process.results import CANCELLED
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import SKIPPED
from buildbot.process.results import SUCCESS
from buildbot.steps import transfer
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectDownloadFile
from buildbot.test.steps import ExpectGlob
from buildbot.test.steps import ExpectRemoteRef
from buildbot.test.steps import ExpectStat
from buildbot.test.steps import ExpectUploadDirectory
from buildbot.test.steps import ExpectUploadFile
from buildbot.test.steps import TestBuildStepMixin
class TestFileUpload(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
fd, self.destfile = tempfile.mkstemp()
os.close(fd)
os.unlink(self.destfile)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
if os.path.exists(self.destfile):
os.unlink(self.destfile)
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def testConstructorModeType(self):
with self.assertRaises(config.ConfigErrors):
transfer.FileUpload(workersrc=__file__, masterdest='xyz', mode='g+rwx')
def testBasic(self):
self.setup_step(transfer.FileUpload(workersrc='srcfile', masterdest=self.destfile))
self.expect_commands(
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="uploading srcfile")
d = self.run_step()
return d
def testWorker2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(transfer.FileUpload(workersrc='srcfile', masterdest=self.destfile))
self.expect_commands(
ExpectUploadFile(
slavesrc="srcfile",
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="uploading srcfile")
d = self.run_step()
return d
@defer.inlineCallbacks
def testTimestamp(self):
self.setup_step(
transfer.FileUpload(workersrc=__file__, masterdest=self.destfile, keepstamp=True)
)
timestamp = (os.path.getatime(__file__), os.path.getmtime(__file__))
self.expect_commands(
ExpectUploadFile(
workersrc=__file__,
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=True,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string('test\n', timestamp=timestamp)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string=f"uploading {os.path.basename(__file__)}")
yield self.run_step()
desttimestamp = (os.path.getatime(self.destfile), os.path.getmtime(self.destfile))
srctimestamp = [int(t) for t in timestamp]
desttimestamp = [int(d) for d in desttimestamp]
self.assertEqual(srctimestamp[0], desttimestamp[0])
self.assertEqual(srctimestamp[1], desttimestamp[1])
def testDescriptionDone(self):
self.setup_step(
transfer.FileUpload(
workersrc=__file__,
masterdest=self.destfile,
url="http://server/file",
descriptionDone="Test File Uploaded",
)
)
self.get_nth_step(0).addURL = Mock()
self.expect_commands(
ExpectUploadFile(
workersrc=__file__,
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="Test File Uploaded")
d = self.run_step()
return d
@defer.inlineCallbacks
def testURL(self):
self.setup_step(
transfer.FileUpload(
workersrc=__file__, masterdest=self.destfile, url="http://server/file"
)
)
self.get_nth_step(0).addURL = Mock()
self.expect_commands(
ExpectUploadFile(
workersrc=__file__,
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string=f"uploading {os.path.basename(__file__)}")
yield self.run_step()
self.get_nth_step(0).addURL.assert_called_once_with(
os.path.basename(self.destfile), "http://server/file"
)
@defer.inlineCallbacks
def testURLText(self):
self.setup_step(
transfer.FileUpload(
workersrc=__file__,
masterdest=self.destfile,
url="http://server/file",
urlText="testfile",
)
)
self.get_nth_step(0).addURL = Mock()
self.expect_commands(
ExpectUploadFile(
workersrc=__file__,
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string=f"uploading {os.path.basename(__file__)}")
yield self.run_step()
self.get_nth_step(0).addURL.assert_called_once_with("testfile", "http://server/file")
def testFailure(self):
self.setup_step(transfer.FileUpload(workersrc='srcfile', masterdest=self.destfile))
self.expect_commands(
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
).exit(1)
)
self.expect_outcome(result=FAILURE, state_string="uploading srcfile (failure)")
d = self.run_step()
return d
@defer.inlineCallbacks
def testException(self):
self.setup_step(transfer.FileUpload(workersrc='srcfile', masterdest=self.destfile))
writers = []
self.expect_commands(
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
).upload_string("Hello world!\n", out_writers=writers, error=RuntimeError('uh oh'))
)
self.expect_outcome(result=EXCEPTION, state_string="uploading srcfile (exception)")
yield self.run_step()
self.assertEqual(len(writers), 1)
self.assertEqual(writers[0].cancel.called, True)
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
@defer.inlineCallbacks
def test_interrupt(self):
self.setup_step(transfer.FileUpload(workersrc='srcfile', masterdest=self.destfile))
self.expect_commands(
ExpectUploadFile(
workersrc='srcfile',
workdir='wkdir',
blocksize=262144,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
interrupted=True,
).exit(0)
)
self.interrupt_nth_remote_command(0)
self.expect_outcome(result=CANCELLED, state_string="uploading srcfile (cancelled)")
self.expect_log_file('interrupt', 'interrupt reason')
yield self.run_step()
def test_init_workersrc_keyword(self):
step = transfer.FileUpload(workersrc='srcfile', masterdest='dstfile')
self.assertEqual(step.workersrc, 'srcfile')
def test_init_workersrc_positional(self):
step = transfer.FileUpload('srcfile', 'dstfile')
self.assertEqual(step.workersrc, 'srcfile')
def test_init_positional_args(self):
with self.assertRaises(TypeError):
transfer.FileUpload()
with self.assertRaises(TypeError):
transfer.FileUpload('src')
class TestDirectoryUpload(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.destdir = os.path.abspath('destdir')
if os.path.exists(self.destdir):
shutil.rmtree(self.destdir)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
if os.path.exists(self.destdir):
shutil.rmtree(self.destdir)
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def testBasic(self):
self.setup_step(transfer.DirectoryUpload(workersrc="srcdir", masterdest=self.destdir))
self.expect_commands(
ExpectUploadDirectory(
workersrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="uploading srcdir")
d = self.run_step()
return d
def testWorker2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
transfer.DirectoryUpload(workersrc="srcdir", masterdest=self.destdir),
)
self.expect_commands(
ExpectUploadDirectory(
slavesrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="uploading srcdir")
d = self.run_step()
return d
@defer.inlineCallbacks
def test_url(self):
self.setup_step(
transfer.DirectoryUpload(
workersrc="srcdir", masterdest=self.destdir, url="http://server/dir"
)
)
self.get_nth_step(0).addURL = Mock()
self.expect_commands(
ExpectUploadDirectory(
workersrc='srcdir',
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="uploading srcdir")
yield self.run_step()
self.get_nth_step(0).addURL.assert_called_once_with("destdir", "http://server/dir")
@defer.inlineCallbacks
def test_url_text(self):
self.setup_step(
transfer.DirectoryUpload(
workersrc="srcdir",
masterdest=self.destdir,
url="http://server/dir",
urlText='url text',
)
)
self.get_nth_step(0).addURL = Mock()
self.expect_commands(
ExpectUploadDirectory(
workersrc='srcdir',
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="uploading srcdir")
yield self.run_step()
self.get_nth_step(0).addURL.assert_called_once_with("url text", "http://server/dir")
@defer.inlineCallbacks
def testFailure(self):
self.setup_step(transfer.DirectoryUpload(workersrc="srcdir", masterdest=self.destdir))
self.expect_commands(
ExpectUploadDirectory(
workersrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
).exit(1)
)
self.expect_outcome(result=FAILURE, state_string="uploading srcdir (failure)")
yield self.run_step()
@defer.inlineCallbacks
def testException(self):
self.setup_step(transfer.DirectoryUpload(workersrc='srcdir', masterdest=self.destdir))
writers = []
self.expect_commands(
ExpectUploadDirectory(
workersrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
).upload_tar_file(
'fake.tar',
{"test": "Hello world!"},
error=RuntimeError('uh oh'),
out_writers=writers,
)
)
self.expect_outcome(result=EXCEPTION, state_string="uploading srcdir (exception)")
yield self.run_step()
self.assertEqual(len(writers), 1)
self.assertEqual(writers[0].cancel.called, True)
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
def test_init_workersrc_keyword(self):
step = transfer.DirectoryUpload(workersrc='srcfile', masterdest='dstfile')
self.assertEqual(step.workersrc, 'srcfile')
def test_init_workersrc_positional(self):
step = transfer.DirectoryUpload('srcfile', 'dstfile')
self.assertEqual(step.workersrc, 'srcfile')
def test_init_positional_args(self):
with self.assertRaises(TypeError):
transfer.DirectoryUpload()
with self.assertRaises(TypeError):
transfer.DirectoryUpload('src')
class TestMultipleFileUpload(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.destdir = os.path.abspath('destdir')
if os.path.exists(self.destdir):
shutil.rmtree(self.destdir)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
if os.path.exists(self.destdir):
shutil.rmtree(self.destdir)
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def testEmpty(self):
self.setup_step(transfer.MultipleFileUpload(workersrcs=[], masterdest=self.destdir))
self.expect_commands()
self.expect_outcome(result=SKIPPED, state_string="finished (skipped)")
d = self.run_step()
return d
def testFile(self):
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["srcfile"], masterdest=self.destdir)
)
self.expect_commands(
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 1 file")
d = self.run_step()
return d
def testDirectory(self):
self.setup_step(transfer.MultipleFileUpload(workersrcs=["srcdir"], masterdest=self.destdir))
self.expect_commands(
ExpectStat(file="srcdir", workdir='wkdir').stat_dir().exit(0),
ExpectUploadDirectory(
workersrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 1 file")
d = self.run_step()
return d
@defer.inlineCallbacks
def test_not_existing_path(self):
self.setup_step(transfer.MultipleFileUpload(workersrcs=["srcdir"], masterdest=self.destdir))
self.expect_commands(ExpectStat(file='srcdir', workdir='wkdir').exit(1))
self.expect_outcome(result=FAILURE, state_string="uploading 1 file (failure)")
self.expect_log_file('stderr', "File wkdir/srcdir not available at worker")
yield self.run_step()
@defer.inlineCallbacks
def test_special_path(self):
self.setup_step(transfer.MultipleFileUpload(workersrcs=["srcdir"], masterdest=self.destdir))
self.expect_commands(ExpectStat(file='srcdir', workdir='wkdir').stat(mode=0).exit(0))
self.expect_outcome(result=FAILURE, state_string="uploading 1 file (failure)")
self.expect_log_file('stderr', 'srcdir is neither a regular file, nor a directory')
yield self.run_step()
def testMultiple(self):
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["srcfile", "srcdir"], masterdest=self.destdir)
)
self.expect_commands(
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
ExpectStat(file="srcdir", workdir='wkdir').stat_dir().exit(0),
ExpectUploadDirectory(
workersrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 2 files")
d = self.run_step()
return d
def testMultipleString(self):
self.setup_step(transfer.MultipleFileUpload(workersrcs="srcfile", masterdest=self.destdir))
self.expect_commands(
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 1 file")
d = self.run_step()
return d
def testGlob(self):
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["src*"], masterdest=self.destdir, glob=True)
)
self.expect_commands(
ExpectGlob(path=os.path.join('wkdir', 'src*'), log_environ=False)
.files(["srcfile"])
.exit(0),
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 1 file")
d = self.run_step()
return d
def testFailedGlob(self):
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["src*"], masterdest=self.destdir, glob=True)
)
self.expect_commands(
ExpectGlob(path=os.path.join('wkdir', 'src*'), log_environ=False).files().exit(1)
)
self.expect_outcome(result=SKIPPED, state_string="uploading 0 files (skipped)")
d = self.run_step()
return d
def testFileWorker2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["srcfile"], masterdest=self.destdir),
)
self.expect_commands(
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
slavesrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 1 file")
d = self.run_step()
return d
def testDirectoryWorker2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["srcdir"], masterdest=self.destdir),
)
self.expect_commands(
ExpectStat(file="srcdir", workdir='wkdir').stat_dir().exit(0),
ExpectUploadDirectory(
slavesrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 1 file")
d = self.run_step()
return d
def testMultipleWorker2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["srcfile", "srcdir"], masterdest=self.destdir),
)
self.expect_commands(
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
slavesrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
ExpectStat(file="srcdir", workdir='wkdir').stat_dir().exit(0),
ExpectUploadDirectory(
slavesrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 2 files")
d = self.run_step()
return d
@defer.inlineCallbacks
def test_url(self):
self.setup_step(
transfer.MultipleFileUpload(
workersrcs=["srcfile"], masterdest=self.destdir, url="http://server/dir"
)
)
self.get_nth_step(0).addURL = Mock()
self.expect_commands(
ExpectStat(file='srcfile', workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc='srcfile',
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 1 file")
yield self.run_step()
self.get_nth_step(0).addURL.assert_called_once_with("destdir", "http://server/dir")
@defer.inlineCallbacks
def test_url_text(self):
self.setup_step(
transfer.MultipleFileUpload(
workersrcs=["srcfile"],
masterdest=self.destdir,
url="http://server/dir",
urlText='url text',
)
)
self.get_nth_step(0).addURL = Mock()
self.expect_commands(
ExpectStat(file='srcfile', workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc='srcfile',
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 1 file")
yield self.run_step()
self.get_nth_step(0).addURL.assert_called_once_with("url text", "http://server/dir")
def testFailure(self):
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["srcfile", "srcdir"], masterdest=self.destdir)
)
self.expect_commands(
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
).exit(1),
)
self.expect_outcome(result=FAILURE, state_string="uploading 2 files (failure)")
d = self.run_step()
return d
@defer.inlineCallbacks
def testException(self):
self.setup_step(
transfer.MultipleFileUpload(workersrcs=["srcfile", "srcdir"], masterdest=self.destdir)
)
writers = []
self.expect_commands(
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
).upload_string("Hello world!\n", out_writers=writers, error=RuntimeError('uh oh')),
)
self.expect_outcome(result=EXCEPTION, state_string="uploading 2 files (exception)")
yield self.run_step()
self.assertEqual(len(writers), 1)
self.assertEqual(writers[0].cancel.called, True)
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
@defer.inlineCallbacks
def testSubclass(self):
class CustomStep(transfer.MultipleFileUpload):
uploadDone = Mock(return_value=None)
allUploadsDone = Mock(return_value=None)
step = CustomStep(workersrcs=["srcfile", "srcdir"], masterdest=self.destdir)
self.setup_step(step)
self.expect_commands(
ExpectStat(file="srcfile", workdir='wkdir').stat_file().exit(0),
ExpectUploadFile(
workersrc="srcfile",
workdir='wkdir',
blocksize=16384,
maxsize=None,
keepstamp=False,
writer=ExpectRemoteRef(remotetransfer.FileWriter),
)
.upload_string("Hello world!\n")
.exit(0),
ExpectStat(file="srcdir", workdir='wkdir').stat_dir().exit(0),
ExpectUploadDirectory(
workersrc="srcdir",
workdir='wkdir',
blocksize=16384,
compress=None,
maxsize=None,
writer=ExpectRemoteRef(remotetransfer.DirectoryWriter),
)
.upload_tar_file('fake.tar', {"test": "Hello world!"})
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="uploading 2 files")
yield self.run_step()
self.assertEqual(step.uploadDone.call_count, 2)
self.assertEqual(
step.uploadDone.call_args_list[0],
((SUCCESS, 'srcfile', os.path.join(self.destdir, 'srcfile')), {}),
)
self.assertEqual(
step.uploadDone.call_args_list[1],
((SUCCESS, 'srcdir', os.path.join(self.destdir, 'srcdir')), {}),
)
self.assertEqual(step.allUploadsDone.call_count, 1)
self.assertEqual(
step.allUploadsDone.call_args_list[0],
((SUCCESS, ['srcfile', 'srcdir'], self.destdir), {}),
)
def test_init_workersrcs_keyword(self):
step = transfer.MultipleFileUpload(workersrcs=['srcfile'], masterdest='dstfile')
self.assertEqual(step.workersrcs, ['srcfile'])
def test_init_workersrcs_positional(self):
step = transfer.MultipleFileUpload(['srcfile'], 'dstfile')
self.assertEqual(step.workersrcs, ['srcfile'])
def test_init_positional_args(self):
with self.assertRaises(TypeError):
transfer.MultipleFileUpload()
with self.assertRaises(TypeError):
transfer.MultipleFileUpload(['srcfile'])
class TestFileDownload(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
fd, self.destfile = tempfile.mkstemp()
os.close(fd)
os.unlink(self.destfile)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
if os.path.exists(self.destfile):
os.unlink(self.destfile)
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_init_workerdest_keyword(self):
step = transfer.FileDownload(mastersrc='srcfile', workerdest='dstfile')
self.assertEqual(step.workerdest, 'dstfile')
def test_init_workerdest_positional(self):
step = transfer.FileDownload('srcfile', 'dstfile')
self.assertEqual(step.workerdest, 'dstfile')
def test_init_positional_args(self):
with self.assertRaises(TypeError):
transfer.FileDownload()
with self.assertRaises(TypeError):
transfer.FileDownload('srcfile')
@defer.inlineCallbacks
def testBasic(self):
master_file = __file__
self.setup_step(transfer.FileDownload(mastersrc=master_file, workerdest=self.destfile))
# A place to store what gets read
read = []
self.expect_commands(
ExpectDownloadFile(
workerdest=self.destfile,
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.FileReader),
)
.download_string(read.append, size=1000)
.exit(0)
)
self.expect_outcome(
result=SUCCESS, state_string=f"downloading to {os.path.basename(self.destfile)}"
)
yield self.run_step()
with open(master_file, "rb") as f:
contents = f.read()
contents = contents[:1000]
self.assertEqual(b''.join(read), contents)
@defer.inlineCallbacks
def testBasicWorker2_16(self):
master_file = __file__
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
transfer.FileDownload(mastersrc=master_file, workerdest=self.destfile),
)
# A place to store what gets read
read = []
self.expect_commands(
ExpectDownloadFile(
slavedest=self.destfile,
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.FileReader),
)
.download_string(read.append, size=1000)
.exit(0)
)
self.expect_outcome(
result=SUCCESS, state_string=f"downloading to {os.path.basename(self.destfile)}"
)
yield self.run_step()
with open(master_file, "rb") as f:
contents = f.read()
contents = contents[:1000]
self.assertEqual(b''.join(read), contents)
@defer.inlineCallbacks
def test_no_file(self):
self.setup_step(
transfer.FileDownload(mastersrc='not existing file', workerdest=self.destfile)
)
self.expect_commands()
self.expect_outcome(
result=FAILURE,
state_string=f"downloading to {os.path.basename(self.destfile)} " "(failure)",
)
self.expect_log_file('stderr', "File 'not existing file' not available at master")
yield self.run_step()
class TestStringDownload(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
# check that ConfigErrors is raised on invalid 'mode' argument
def testModeConfError(self):
with self.assertRaisesRegex(
config.ConfigErrors,
"StringDownload step's mode must be an integer or None, got 'not-a-number'",
):
transfer.StringDownload("string", "file", mode="not-a-number")
@defer.inlineCallbacks
def testBasic(self):
self.setup_step(transfer.StringDownload("Hello World", "hello.txt"))
self.get_nth_step(0).worker = Mock()
self.get_nth_step(0).remote = Mock()
# A place to store what gets read
read = []
self.expect_commands(
ExpectDownloadFile(
workerdest="hello.txt",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
)
.download_string(read.append)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="downloading to hello.txt")
yield self.run_step()
self.assertEqual(b''.join(read), b"Hello World")
@defer.inlineCallbacks
def testBasicWorker2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(transfer.StringDownload("Hello World", "hello.txt"))
self.get_nth_step(0).worker = Mock()
self.get_nth_step(0).remote = Mock()
# A place to store what gets read
read = []
self.expect_commands(
ExpectDownloadFile(
slavedest="hello.txt",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
)
.download_string(read.append)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="downloading to hello.txt")
yield self.run_step()
self.assertEqual(b''.join(read), b"Hello World")
def testFailure(self):
self.setup_step(transfer.StringDownload("Hello World", "hello.txt"))
self.expect_commands(
ExpectDownloadFile(
workerdest="hello.txt",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
).exit(1)
)
self.expect_outcome(result=FAILURE, state_string="downloading to hello.txt (failure)")
return self.run_step()
def test_init_workerdest_keyword(self):
step = transfer.StringDownload('srcfile', workerdest='dstfile')
self.assertEqual(step.workerdest, 'dstfile')
def test_init_workerdest_positional(self):
step = transfer.StringDownload('srcfile', 'dstfile')
self.assertEqual(step.workerdest, 'dstfile')
def test_init_positional_args(self):
with self.assertRaises(TypeError):
transfer.StringDownload()
with self.assertRaises(TypeError):
transfer.StringDownload('srcfile')
class TestJSONStringDownload(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def testBasic(self):
msg = {"message": 'Hello World'}
self.setup_step(transfer.JSONStringDownload(msg, "hello.json"))
self.get_nth_step(0).worker = Mock()
self.get_nth_step(0).remote = Mock()
# A place to store what gets read
read = []
self.expect_commands(
ExpectDownloadFile(
workerdest="hello.json",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
)
.download_string(read.append)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="downloading to hello.json")
yield self.run_step()
self.assertEqual(b''.join(read), b'{"message": "Hello World"}')
@defer.inlineCallbacks
def test_basic_with_renderable(self):
msg = {"message": Interpolate('Hello World')}
self.setup_step(transfer.JSONStringDownload(msg, "hello.json"))
self.get_nth_step(0).worker = Mock()
self.get_nth_step(0).remote = Mock()
# A place to store what gets read
read = []
self.expect_commands(
ExpectDownloadFile(
workerdest="hello.json",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
)
.download_string(read.append)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="downloading to hello.json")
yield self.run_step()
self.assertEqual(b''.join(read), b'{"message": "Hello World"}')
def testFailure(self):
msg = {"message": 'Hello World'}
self.setup_step(transfer.JSONStringDownload(msg, "hello.json"))
self.expect_commands(
ExpectDownloadFile(
workerdest="hello.json",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
).exit(1)
)
self.expect_outcome(result=FAILURE, state_string="downloading to hello.json (failure)")
return self.run_step()
def test_init_workerdest_keyword(self):
step = transfer.JSONStringDownload('srcfile', workerdest='dstfile')
self.assertEqual(step.workerdest, 'dstfile')
def test_init_workerdest_positional(self):
step = transfer.JSONStringDownload('srcfile', 'dstfile')
self.assertEqual(step.workerdest, 'dstfile')
def test_init_positional_args(self):
with self.assertRaises(TypeError):
transfer.JSONStringDownload()
with self.assertRaises(TypeError):
transfer.JSONStringDownload('srcfile')
class TestJSONPropertiesDownload(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def testBasic(self):
self.setup_step(transfer.JSONPropertiesDownload("props.json"))
self.get_nth_step(0).build.setProperty('key1', 'value1', 'test')
read = []
self.expect_commands(
ExpectDownloadFile(
workerdest="props.json",
workdir='wkdir',
blocksize=16384,
maxsize=None,
mode=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
)
.download_string(read.append)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="downloading to props.json")
yield self.run_step()
# we decode as key order is dependent of python version
self.assertEqual(
json.loads((b''.join(read)).decode()),
{"properties": {"key1": "value1"}, "sourcestamps": []},
)
def test_init_workerdest_keyword(self):
step = transfer.JSONPropertiesDownload(workerdest='dstfile')
self.assertEqual(step.workerdest, 'dstfile')
def test_init_workerdest_positional(self):
step = transfer.JSONPropertiesDownload('dstfile')
self.assertEqual(step.workerdest, 'dstfile')
def test_init_positional_args(self):
with self.assertRaises(TypeError):
transfer.JSONPropertiesDownload()
| 43,865 | Python | .py | 1,075 | 29.503256 | 100 | 0.597278 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,480 | test_package_deb_pbuilder.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_package_deb_pbuilder.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import time
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process.properties import Interpolate
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.steps.package.deb import pbuilder
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.steps import TestBuildStepMixin
class TestDebPbuilder(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_new(self):
self.setup_step(pbuilder.DebPbuilder())
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string='built')
return self.run_step()
def test_update(self):
self.setup_step(pbuilder.DebPbuilder())
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.tgz').stat_file().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--update',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_buildonly_and_property(self):
self.setup_step(pbuilder.DebPbuilder())
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.tgz')
.stat_file(mtime=int(time.time()))
.exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
],
)
.stdout('blah\ndpkg-genchanges >../somefilename.changes\foo\n')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('deb-changes', 'somefilename.changes', 'DebPbuilder')
return self.run_step()
def test_architecture(self):
self.setup_step(pbuilder.DebPbuilder(architecture='amd64'))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-amd64-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/stable-amd64-buildbot.tgz',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
'--architecture',
'amd64',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--architecture',
'amd64',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-amd64-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_architecture_renderable(self):
self.setup_step(pbuilder.DebPbuilder(architecture=Interpolate('amd64')))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-amd64-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/stable-amd64-buildbot.tgz',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
'--architecture',
'amd64',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--architecture',
'amd64',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-amd64-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_distribution(self):
self.setup_step(pbuilder.DebPbuilder(distribution='woody'))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/woody-local-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/woody-local-buildbot.tgz',
'--distribution',
'woody',
'--mirror',
'http://cdn.debian.net/debian/',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/woody-local-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_basetgz(self):
self.setup_step(pbuilder.DebPbuilder(basetgz='/buildbot/stable-local.tgz'))
self.expect_commands(
ExpectStat(file='/buildbot/stable-local.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/buildbot/stable-local.tgz',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/buildbot/stable-local.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mirror(self):
self.setup_step(pbuilder.DebPbuilder(mirror='http://apt:9999/debian'))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
'--distribution',
'stable',
'--mirror',
'http://apt:9999/debian',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_extrapackages(self):
self.setup_step(pbuilder.DebPbuilder(extrapackages=['buildbot']))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
'--extrapackages',
'buildbot',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
'--extrapackages',
'buildbot',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_keyring(self):
self.setup_step(pbuilder.DebPbuilder(keyring='/builbot/buildbot.gpg'))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
'--debootstrapopts',
'--keyring=/builbot/buildbot.gpg',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_components(self):
self.setup_step(pbuilder.DebPbuilder(components='main universe'))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
'--components',
'main universe',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_othermirror(self):
self.setup_step(pbuilder.DebPbuilder(othermirror=['http://apt:9999/debian']))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
'--othermirror',
'http://apt:9999/debian',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/stable-local-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
class TestDebCowbuilder(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_new(self):
self.setup_step(pbuilder.DebCowbuilder())
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.cow/').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/cowbuilder',
'--create',
'--basepath',
'/var/cache/pbuilder/stable-local-buildbot.cow/',
'--distribution',
'stable',
'--mirror',
'http://cdn.debian.net/debian/',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/cowbuilder',
'--',
'--buildresult',
'.',
'--basepath',
'/var/cache/pbuilder/stable-local-buildbot.cow/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_update(self):
self.setup_step(pbuilder.DebCowbuilder())
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.cow/').stat_dir().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/cowbuilder',
'--update',
'--basepath',
'/var/cache/pbuilder/stable-local-buildbot.cow/',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/cowbuilder',
'--',
'--buildresult',
'.',
'--basepath',
'/var/cache/pbuilder/stable-local-buildbot.cow/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_buildonly(self):
self.setup_step(pbuilder.DebCowbuilder())
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.cow/')
.stat_dir(mtime=int(time.time()))
.exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/cowbuilder',
'--',
'--buildresult',
'.',
'--basepath',
'/var/cache/pbuilder/stable-local-buildbot.cow/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_update_reg(self):
self.setup_step(
pbuilder.DebCowbuilder(basetgz='/var/cache/pbuilder/stable-local-buildbot.cow')
)
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.cow').stat_file().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/cowbuilder',
'--update',
'--basepath',
'/var/cache/pbuilder/stable-local-buildbot.cow',
],
).exit(1),
)
self.expect_outcome(result=FAILURE, state_string='built (failure)')
return self.run_step()
def test_buildonly_reg(self):
self.setup_step(
pbuilder.DebCowbuilder(basetgz='/var/cache/pbuilder/stable-local-buildbot.cow')
)
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/stable-local-buildbot.cow')
.stat_file(mtime=int(time.time()))
.exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/cowbuilder',
'--',
'--buildresult',
'.',
'--basepath',
'/var/cache/pbuilder/stable-local-buildbot.cow',
],
).exit(1),
)
self.expect_outcome(result=FAILURE, state_string='built (failure)')
return self.run_step()
class TestUbuPbuilder(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_no_distribution(self):
with self.assertRaises(config.ConfigErrors):
pbuilder.UbuPbuilder()
def test_new(self):
self.setup_step(pbuilder.UbuPbuilder(distribution='oneiric'))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/oneiric-local-buildbot.tgz').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/pbuilder',
'--create',
'--basetgz',
'/var/cache/pbuilder/oneiric-local-buildbot.tgz',
'--distribution',
'oneiric',
'--mirror',
'http://archive.ubuntu.com/ubuntu/',
'--components',
'main universe',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/pbuilder',
'--',
'--buildresult',
'.',
'--basetgz',
'/var/cache/pbuilder/oneiric-local-buildbot.tgz',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string='built')
return self.run_step()
class TestUbuCowbuilder(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_no_distribution(self):
with self.assertRaises(config.ConfigErrors):
pbuilder.UbuCowbuilder()
def test_new(self):
self.setup_step(pbuilder.UbuCowbuilder(distribution='oneiric'))
self.expect_commands(
ExpectStat(file='/var/cache/pbuilder/oneiric-local-buildbot.cow/').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'sudo',
'/usr/sbin/cowbuilder',
'--create',
'--basepath',
'/var/cache/pbuilder/oneiric-local-buildbot.cow/',
'--distribution',
'oneiric',
'--mirror',
'http://archive.ubuntu.com/ubuntu/',
'--components',
'main universe',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'pdebuild',
'--buildresult',
'.',
'--pbuilder',
'/usr/sbin/cowbuilder',
'--',
'--buildresult',
'.',
'--basepath',
'/var/cache/pbuilder/oneiric-local-buildbot.cow/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string='built')
return self.run_step()
| 25,956 | Python | .py | 714 | 20.512605 | 97 | 0.434579 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,481 | test_source_mtn.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_mtn.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.internet import error
from twisted.trial import unittest
from buildbot.process import remotetransfer
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.steps.source import mtn
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectCpdir
from buildbot.test.steps import ExpectDownloadFile
from buildbot.test.steps import ExpectRemoteRef
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.util import config
from buildbot.test.util import sourcesteps
class TestMonotone(
sourcesteps.SourceStepMixin, config.ConfigErrorsMixin, TestReactorMixin, unittest.TestCase
):
# Just some random revision id to test.
REVID = '95215e2a9a9f8b6f5c9664e3807cd34617ea928c'
MTN_VER = 'monotone 1.0 (base revision: UNKNOWN_REV)'
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setUpSourceStep()
@defer.inlineCallbacks
def tearDown(self):
yield self.tearDownSourceStep()
yield self.tear_down_test_reactor()
def test_mode_full_clean(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clean', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'ls', 'unknown'])
.stdout('file1\nfile2')
.exit(0),
ExpectRmdir(dir=['wkdir/file1', 'wkdir/file2'], log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_clean_patch(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clean', branch='master'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'ls', 'unknown'])
.stdout('file1\nfile2')
.exit(0),
ExpectRmdir(dir=['wkdir/file1', 'wkdir/file2'], log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'patch',
'-p1',
'--remove-empty-files',
'--force',
'--forward',
'-i',
'.buildbot-diff',
],
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_clean_patch_worker_2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clean', branch='master'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'ls', 'unknown'])
.stdout('file1\nfile2')
.exit(0),
ExpectRmdir(dir=['wkdir/file1', 'wkdir/file2'], log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'patch',
'-p1',
'--remove-empty-files',
'--force',
'--forward',
'-i',
'.buildbot-diff',
],
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_clean_patch_fail(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clean', branch='master'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'ls', 'unknown'])
.stdout('file1\nfile2')
.exit(0),
ExpectRmdir(dir=['wkdir/file1', 'wkdir/file2'], log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'patch',
'-p1',
'--remove-empty-files',
'--force',
'--forward',
'-i',
'.buildbot-diff',
],
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(1),
)
self.expect_outcome(result=FAILURE, state_string="update (failure)")
return self.run_step()
def test_mode_full_clean_no_existing_db(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clean', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(1),
ExpectShell(workdir='.', command=['mtn', 'db', 'init', '--db', 'db.mtn']).exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'ls', 'unknown'])
.stdout('file1\nfile2')
.exit(0),
ExpectRmdir(dir=['wkdir/file1', 'wkdir/file2'], log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_clean_no_existing_checkout(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clean', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=['mtn', 'checkout', 'wkdir', '--db', 'db.mtn', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_clean_from_scratch(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clean', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(1),
ExpectShell(workdir='.', command=['mtn', 'db', 'init', '--db', 'db.mtn']).exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=['mtn', 'checkout', 'wkdir', '--db', 'db.mtn', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_clobber(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clobber', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=['mtn', 'checkout', 'wkdir', '--db', 'db.mtn', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_clobber_no_existing_db(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clobber', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(1),
ExpectShell(workdir='.', command=['mtn', 'db', 'init', '--db', 'db.mtn']).exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=['mtn', 'checkout', 'wkdir', '--db', 'db.mtn', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_incremental_no_existing_db(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(1),
ExpectShell(workdir='.', command=['mtn', 'db', 'init', '--db', 'db.mtn']).exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_incremental_no_existing_checkout(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=['mtn', 'checkout', 'wkdir', '--db', 'db.mtn', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_incremental_from_scratch(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(1),
ExpectShell(workdir='.', command=['mtn', 'db', 'init', '--db', 'db.mtn']).exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=['mtn', 'checkout', 'wkdir', '--db', 'db.mtn', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_incremental(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_incremental_retry(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone',
mode='incremental',
branch='master',
retry=(0, 1),
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(1),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_fresh(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='fresh', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'ls', 'unknown'])
.stdout('file1\nfile2')
.exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'ls', 'ignored'])
.stdout('file3\nfile4')
.exit(0),
ExpectRmdir(
dir=['wkdir/file1', 'wkdir/file2', 'wkdir/file3', 'wkdir/file4'], log_environ=True
).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_incremental_given_revision(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master'),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'abcdef01', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout('abcdef019a9f8b6f5c9664e3807cd34617ea928c')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'abcdef019a9f8b6f5c9664e3807cd34617ea928c', 'Monotone')
return self.run_step()
def test_mode_full_copy(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='copy', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectStat(file='source/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='source',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectCpdir(fromdir='source', todir='build', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='build', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_mode_full_no_method(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='full', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectStat(file='source/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='source',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectCpdir(fromdir='source', todir='build', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='build', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_incorrect_method(self):
with self.assertRaisesConfigError("Invalid method for mode == full"):
mtn.Monotone(
repourl='mtn://localhost/monotone',
mode='full',
method='wrongmethod',
branch='master',
)
def test_incremental_invalid_method(self):
with self.assertRaisesConfigError("Incremental mode does not require method"):
mtn.Monotone(
repourl='mtn://localhost/monotone',
mode='incremental',
method='fresh',
branch="master",
)
def test_repourl(self):
with self.assertRaisesConfigError("must provide repourl"):
mtn.Monotone(mode="full", branch="master")
def test_branch(self):
with self.assertRaisesConfigError("must provide branch"):
mtn.Monotone(
repourl='mtn://localhost/monotone',
mode="full",
)
def test_mode_incremental_patched(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('')
.exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'ls', 'unknown'])
.stdout('file1\nfile2')
.exit(0),
ExpectRmdir(dir=['wkdir/file1', 'wkdir/file2'], log_environ=True).exit(0),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_worker_connection_lost(self):
self.setup_step(
mtn.Monotone(
repourl='mtn://localhost/monotone', mode='full', method='clean', branch='master'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version'])
.stdout(self.MTN_VER)
.error(error.ConnectionLost())
)
self.expect_outcome(result=RETRY, state_string="update (retry)")
return self.run_step()
def test_database_migration(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('migration needed')
.exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'migrate', '--db', 'db.mtn']).exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_database_invalid(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('not a monotone database')
.exit(0),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_database_too_new(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('too new, cannot use')
.exit(0),
ExpectRmdir(dir='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'init', '--db', 'db.mtn']).exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
def test_database_empty(self):
self.setup_step(
mtn.Monotone(repourl='mtn://localhost/monotone', mode='incremental', branch='master')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['mtn', '--version']).stdout(self.MTN_VER).exit(0),
ExpectStat(file='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'info', '--db', 'db.mtn'])
.stdout('database has no tables')
.exit(0),
ExpectRmdir(dir='db.mtn', log_environ=True).exit(0),
ExpectShell(workdir='.', command=['mtn', 'db', 'init', '--db', 'db.mtn']).exit(0),
ExpectShell(
workdir='.',
command=[
'mtn',
'pull',
'mtn://localhost/monotone?master',
'--db',
'db.mtn',
'--ticker=dot',
],
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_MTN', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['mtn', 'update', '--revision', 'h:master', '--branch', 'master'],
).exit(0),
ExpectShell(workdir='wkdir', command=['mtn', 'automate', 'select', 'w:'])
.stdout(self.REVID)
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', self.REVID, 'Monotone')
return self.run_step()
| 42,296 | Python | .py | 1,001 | 28.555445 | 100 | 0.495902 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,482 | test_source_darcs.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_darcs.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.internet import error
from twisted.trial import unittest
from buildbot import config
from buildbot.process import remotetransfer
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.steps.source import darcs
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectCpdir
from buildbot.test.steps import ExpectDownloadFile
from buildbot.test.steps import ExpectRemoteRef
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.util import sourcesteps
class TestDarcs(sourcesteps.SourceStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setUpSourceStep()
@defer.inlineCallbacks
def tearDown(self):
yield self.tearDownSourceStep()
yield self.tear_down_test_reactor()
def test_no_empty_step_config(self):
with self.assertRaises(config.ConfigErrors):
darcs.Darcs()
def test_incorrect_method(self):
with self.assertRaises(config.ConfigErrors):
darcs.Darcs(repourl='http://localhost/darcs', mode='full', method='fresh')
def test_incremental_invalid_method(self):
with self.assertRaises(config.ConfigErrors):
darcs.Darcs(repourl='http://localhost/darcs', mode='incremental', method='fresh')
def test_no_repo_url(self):
with self.assertRaises(config.ConfigErrors):
darcs.Darcs(mode='full', method='fresh')
def test_mode_full_clobber(self):
self.setup_step(
darcs.Darcs(repourl='http://localhost/darcs', mode='full', method='clobber')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=[
'darcs',
'get',
'--verbose',
'--lazy',
'--repo-name',
'wkdir',
'http://localhost/darcs',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_full_copy(self):
self.setup_step(darcs.Darcs(repourl='http://localhost/darcs', mode='full', method='copy'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectStat(file='source/_darcs', log_environ=True).exit(0),
ExpectShell(workdir='source', command=['darcs', 'pull', '--all', '--verbose']).exit(0),
ExpectCpdir(fromdir='source', todir='build', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='build', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_full_no_method(self):
self.setup_step(darcs.Darcs(repourl='http://localhost/darcs', mode='full'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectStat(file='source/_darcs', log_environ=True).exit(0),
ExpectShell(workdir='source', command=['darcs', 'pull', '--all', '--verbose']).exit(0),
ExpectCpdir(fromdir='source', todir='build', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='build', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_incremental(self):
self.setup_step(darcs.Darcs(repourl='http://localhost/darcs', mode='incremental'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_darcs', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'pull', '--all', '--verbose']).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_incremental_patched(self):
self.setup_step(darcs.Darcs(repourl='http://localhost/darcs', mode='incremental'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectStat(file='source/_darcs', log_environ=True).exit(0),
ExpectShell(workdir='source', command=['darcs', 'pull', '--all', '--verbose']).exit(0),
ExpectCpdir(fromdir='source', todir='build', log_environ=True, timeout=1200).exit(0),
ExpectStat(file='build/_darcs', log_environ=True).exit(0),
ExpectShell(workdir='build', command=['darcs', 'pull', '--all', '--verbose']).exit(0),
ExpectShell(workdir='build', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_incremental_patch(self):
self.setup_step(
darcs.Darcs(repourl='http://localhost/darcs', mode='incremental'), patch=(1, 'patch')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_darcs', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'pull', '--all', '--verbose']).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'patch',
'-p1',
'--remove-empty-files',
'--force',
'--forward',
'-i',
'.buildbot-diff',
],
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_full_clobber_retry(self):
self.setup_step(
darcs.Darcs(
repourl='http://localhost/darcs', mode='full', method='clobber', retry=(0, 2)
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=[
'darcs',
'get',
'--verbose',
'--lazy',
'--repo-name',
'wkdir',
'http://localhost/darcs',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=[
'darcs',
'get',
'--verbose',
'--lazy',
'--repo-name',
'wkdir',
'http://localhost/darcs',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='.',
command=[
'darcs',
'get',
'--verbose',
'--lazy',
'--repo-name',
'wkdir',
'http://localhost/darcs',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_full_clobber_revision(self):
self.setup_step(
darcs.Darcs(repourl='http://localhost/darcs', mode='full', method='clobber'),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.darcs-context',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='.',
command=[
'darcs',
'get',
'--verbose',
'--lazy',
'--repo-name',
'wkdir',
'--context',
'.darcs-context',
'http://localhost/darcs',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_full_clobber_revision_worker_2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
darcs.Darcs(repourl='http://localhost/darcs', mode='full', method='clobber'),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.darcs-context',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='.',
command=[
'darcs',
'get',
'--verbose',
'--lazy',
'--repo-name',
'wkdir',
'--context',
'.darcs-context',
'http://localhost/darcs',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_mode_incremental_no_existing_repo(self):
self.setup_step(darcs.Darcs(repourl='http://localhost/darcs', mode='incremental'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/_darcs', log_environ=True).exit(1),
ExpectShell(
workdir='.',
command=[
'darcs',
'get',
'--verbose',
'--lazy',
'--repo-name',
'wkdir',
'http://localhost/darcs',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['darcs', 'changes', '--max-count=1'])
.stdout('Tue Aug 20 09:18:41 IST 2013 [email protected]')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'Tue Aug 20 09:18:41 IST 2013 [email protected]', 'Darcs')
return self.run_step()
def test_worker_connection_lost(self):
self.setup_step(
darcs.Darcs(repourl='http://localhost/darcs', mode='full', method='clobber')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['darcs', '--version']).error(
error.ConnectionLost()
)
)
self.expect_outcome(result=RETRY, state_string="update (retry)")
return self.run_step()
| 16,283 | Python | .py | 354 | 33.381356 | 99 | 0.55434 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,483 | test_source_base_Source.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_base_Source.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from unittest import mock
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process import results
from buildbot.steps.source import Source
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import TestBuildStepMixin
from buildbot.test.util import sourcesteps
class OldStyleSourceStep(Source):
def startVC(self):
self.finished(results.SUCCESS)
class TestSource(sourcesteps.SourceStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def setup_deferred_mock(self):
m = mock.Mock()
def wrapper(*args, **kwargs):
m(*args, **kwargs)
return results.SUCCESS
wrapper.mock = m
return wrapper
def test_start_alwaysUseLatest_True(self):
step = self.setup_step(
Source(alwaysUseLatest=True),
{
'branch': 'other-branch',
'revision': 'revision',
},
patch='patch',
)
step.branch = 'branch'
step.run_vc = self.setup_deferred_mock()
step.startStep(mock.Mock())
self.assertEqual(step.run_vc.mock.call_args, (('branch', None, None), {}))
def test_start_alwaysUseLatest_False(self):
step = self.setup_step(
Source(),
{
'branch': 'other-branch',
'revision': 'revision',
},
patch='patch',
)
step.branch = 'branch'
step.run_vc = self.setup_deferred_mock()
step.startStep(mock.Mock())
self.assertEqual(step.run_vc.mock.call_args, (('other-branch', 'revision', 'patch'), {}))
def test_start_alwaysUseLatest_False_binary_patch(self):
args = {
'branch': 'other-branch',
'revision': 'revision',
}
step = self.setup_step(Source(), args, patch=(1, b'patch\xf8'))
step.branch = 'branch'
step.run_vc = self.setup_deferred_mock()
step.startStep(mock.Mock())
self.assertEqual(
step.run_vc.mock.call_args, (('other-branch', 'revision', (1, b'patch\xf8')), {})
)
def test_start_alwaysUseLatest_False_no_branch(self):
step = self.setup_step(Source())
step.branch = 'branch'
step.run_vc = self.setup_deferred_mock()
step.startStep(mock.Mock())
self.assertEqual(step.run_vc.mock.call_args, (('branch', None, None), {}))
def test_start_no_codebase(self):
step = self.setup_step(Source())
step.branch = 'branch'
step.run_vc = self.setup_deferred_mock()
step.build.getSourceStamp = mock.Mock()
step.build.getSourceStamp.return_value = None
self.assertEqual(step.getCurrentSummary(), {'step': 'updating'})
self.assertEqual(step.name, Source.name)
step.startStep(mock.Mock())
self.assertEqual(step.build.getSourceStamp.call_args[0], ('',))
self.assertEqual(step.getCurrentSummary(), {'step': 'updating'})
@defer.inlineCallbacks
def test_start_with_codebase(self):
step = self.setup_step(Source(codebase='codebase'))
step.branch = 'branch'
step.run_vc = self.setup_deferred_mock()
step.build.getSourceStamp = mock.Mock()
step.build.getSourceStamp.return_value = None
self.assertEqual(step.getCurrentSummary(), {'step': 'updating codebase'})
step.name = yield step.build.render(step.name)
self.assertEqual(step.name, Source.name + "-codebase")
step.startStep(mock.Mock())
self.assertEqual(step.build.getSourceStamp.call_args[0], ('codebase',))
self.assertEqual(
step.getResultSummary(), {'step': 'Codebase codebase not in build codebase (failure)'}
)
@defer.inlineCallbacks
def test_start_with_codebase_and_descriptionSuffix(self):
step = self.setup_step(Source(codebase='my-code', descriptionSuffix='suffix'))
step.branch = 'branch'
step.run_vc = self.setup_deferred_mock()
step.build.getSourceStamp = mock.Mock()
step.build.getSourceStamp.return_value = None
self.assertEqual(step.getCurrentSummary(), {'step': 'updating suffix'})
step.name = yield step.build.render(step.name)
self.assertEqual(step.name, Source.name + "-my-code")
step.startStep(mock.Mock())
self.assertEqual(step.build.getSourceStamp.call_args[0], ('my-code',))
self.assertEqual(
step.getResultSummary(), {'step': 'Codebase my-code not in build suffix (failure)'}
)
def test_old_style_source_step_throws_exception(self):
step = self.setup_step(OldStyleSourceStep())
step.startStep(mock.Mock())
self.expect_outcome(result=results.EXCEPTION)
self.flushLoggedErrors(NotImplementedError)
class TestSourceDescription(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_constructor_args_strings(self):
step = Source(
workdir='build', description='svn update (running)', descriptionDone='svn update'
)
self.assertEqual(step.description, ['svn update (running)'])
self.assertEqual(step.descriptionDone, ['svn update'])
def test_constructor_args_lists(self):
step = Source(
workdir='build',
description=['svn', 'update', '(running)'],
descriptionDone=['svn', 'update'],
)
self.assertEqual(step.description, ['svn', 'update', '(running)'])
self.assertEqual(step.descriptionDone, ['svn', 'update'])
class AttrGroup(Source):
def other_method(self):
pass
def mode_full(self):
pass
def mode_incremental(self):
pass
class TestSourceAttrGroup(sourcesteps.SourceStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_attrgroup_hasattr(self):
step = AttrGroup()
self.assertTrue(step._hasAttrGroupMember('mode', 'full'))
self.assertTrue(step._hasAttrGroupMember('mode', 'incremental'))
self.assertFalse(step._hasAttrGroupMember('mode', 'nothing'))
def test_attrgroup_getattr(self):
step = AttrGroup()
self.assertEqual(step._getAttrGroupMember('mode', 'full'), step.mode_full)
self.assertEqual(step._getAttrGroupMember('mode', 'incremental'), step.mode_incremental)
with self.assertRaises(AttributeError):
step._getAttrGroupMember('mode', 'nothing')
def test_attrgroup_listattr(self):
step = AttrGroup()
self.assertEqual(sorted(step._listAttrGroupMembers('mode')), ['full', 'incremental'])
| 8,105 | Python | .py | 181 | 36.701657 | 98 | 0.660526 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,484 | test_source_cvs.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_cvs.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import time
from twisted.internet import defer
from twisted.internet import error
from twisted.trial import unittest
from buildbot.process import remotetransfer
from buildbot.process.buildstep import create_step_from_step_or_factory
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.steps.source import cvs
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectCpdir
from buildbot.test.steps import ExpectDownloadFile
from buildbot.test.steps import ExpectRemoteRef
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.steps import ExpectUploadFile
from buildbot.test.util import sourcesteps
class TestCVS(sourcesteps.SourceStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setUpSourceStep()
@defer.inlineCallbacks
def tearDown(self):
yield self.tearDownSourceStep()
yield self.tear_down_test_reactor()
def setup_step(self, step, *args, **kwargs):
super().setup_step(step, *args, **kwargs)
# make parseGotRevision return something consistent, patching the class
# instead of the object since a new object is constructed by runTest.
def parseGotRevision(self):
self.updateSourceProperty('got_revision', '2012-09-09 12:00:39 +0000')
self.patch(cvs.CVS, 'parseGotRevision', parseGotRevision)
def test_parseGotRevision(self):
def gmtime():
return time.struct_time((2012, 9, 9, 12, 9, 33, 6, 253, 0))
self.patch(time, 'gmtime', gmtime)
step = create_step_from_step_or_factory(
cvs.CVS(cvsroot="x", cvsmodule="m", mode='full', method='clean')
)
props = []
def updateSourceProperty(prop, name):
props.append((prop, name))
step.updateSourceProperty = updateSourceProperty
step.parseGotRevision()
self.assertEqual(props, [('got_revision', '2012-09-09 12:09:33 +0000')])
def test_cvsEntriesContainStickyDates(self):
step = cvs.CVS(cvsroot="x", cvsmodule="m", mode='full', method='clean')
self.assertEqual(step._cvsEntriesContainStickyDates('D'), False)
self.assertEqual(
step._cvsEntriesContainStickyDates(
'/file/1.1/Fri May 17 23:20:00//TMOZILLA_1_0_0_BRANCH\nD'
),
False,
)
self.assertEqual(
step._cvsEntriesContainStickyDates(
'/file/1.1/Fri May 17 23:20:00//D2013.10.08.11.20.33\nD'
),
True,
)
self.assertEqual(
step._cvsEntriesContainStickyDates(
'/file1/1.1/Fri May 17 23:20:00//\n'
'/file2/1.1.2.3/Fri May 17 23:20:00//D2013.10.08.11.20.33\nD'
),
True,
)
def test_mode_full_clean_and_login(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
login="a password",
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'login',
],
initial_stdin="a password\n",
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard']).exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="update")
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clean_and_login_worker_2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
login="a password",
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'login',
],
initial_stdin="a password\n",
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
slavesrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
slavesrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
slavesrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard']).exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="update")
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clean_patch(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard']).exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard']).exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'patch',
'-p1',
'--remove-empty-files',
'--force',
'--forward',
'-i',
'.buildbot-diff',
],
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clean_patch_worker_2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard']).exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
slavesrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
slavesrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
slavesrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard']).exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'patch',
'-p1',
'--remove-empty-files',
'--force',
'--forward',
'-i',
'.buildbot-diff',
],
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clean_timeout(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
timeout=1,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', timeout=1, command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', timeout=1, command=['cvsdiscard']).exit(0),
ExpectShell(workdir='wkdir', timeout=1, command=['cvs', '-z3', 'update', '-dP']).exit(
0
),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clean_branch(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
branch='branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard']).exit(0),
ExpectShell(
workdir='wkdir', command=['cvs', '-z3', 'update', '-dP', '-r', 'branch']
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clean_branch_sourcestamp(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
),
args={'branch': 'my_branch'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard']).exit(0),
ExpectShell(
workdir='wkdir', command=['cvs', '-z3', 'update', '-dP', '-r', 'my_branch']
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_fresh(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='fresh',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard', '--ignore']).exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clobber(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clobber',
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clobber_retry(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clobber',
retry=(0, 2),
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_copy(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='copy',
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='source/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='source/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='source/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='source', command=['cvs', '-z3', 'update', '-dP']).exit(0),
ExpectCpdir(
fromdir='source', todir='wkdir', log_environ=True, timeout=step.timeout
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_copy_wrong_repo(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='copy',
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='source/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('the-end-of-the-universe\n')
.exit(0),
ExpectRmdir(dir='source', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'source',
'mozilla/browser/',
],
).exit(0),
ExpectCpdir(
fromdir='source', todir='wkdir', log_environ=True, timeout=step.timeout
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_sticky_date(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//D2013.10.08.11.20.33\nD\n')
.exit(0),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_password_windows(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:dustin:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
# on Windows, this file does not contain the password, per
# http://trac.buildbot.net/ticket/2355
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_branch(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
branch='my_branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(
workdir='wkdir', command=['cvs', '-z3', 'update', '-dP', '-r', 'my_branch']
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_special_case(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
branch='HEAD',
),
args={"revision": '2012-08-16 16:05:16 +0000'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(
workdir='wkdir',
command=[
'cvs',
'-z3',
'update',
'-dP',
# note, no -r HEAD here - that's the special
# case
'-D',
'2012-08-16 16:05:16 +0000',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_branch_sourcestamp(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
),
args={'branch': 'my_branch'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(
workdir='wkdir', command=['cvs', '-z3', 'update', '-dP', '-r', 'my_branch']
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_not_loggedin(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_no_existing_repo(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_retry(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
retry=(0, 1),
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_wrong_repo(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('the-end-of-the-universe\n')
.exit(0),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_wrong_module(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('the-end-of-the-universe\n')
.exit(0),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clean_no_existing_repo(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
).exit(1),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_clean_wrong_repo(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('the-end-of-the-universe\n')
.exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_full_no_method(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard', '--ignore']).exit(0),
ExpectShell(workdir='wkdir', command=['cvs', '-z3', 'update', '-dP']).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_with_options(self):
step = cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
global_options=['-q'],
extra_options=['-l'],
)
self.setup_step(step)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=step.timeout).exit(0),
ExpectShell(
workdir='',
command=[
'cvs',
'-q',
'-d',
':pserver:[email protected]:/cvsroot',
'-z3',
'checkout',
'-d',
'wkdir',
'-l',
'mozilla/browser/',
],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_mode_incremental_with_env_log_environ(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
env={'abc': '123'},
logEnviron=False,
)
)
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['cvs', '--version'], env={'abc': '123'}, log_environ=False
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=False).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(
workdir='wkdir',
command=['cvs', '-z3', 'update', '-dP'],
env={'abc': '123'},
log_environ=False,
).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '2012-09-09 12:00:39 +0000', 'CVS')
return self.run_step()
def test_command_fails(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='incremental',
)
)
self.expect_commands(ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(128))
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_cvsdiscard_fails(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='fresh',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Root',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string(':pserver:[email protected]:/cvsroot\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Repository',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('mozilla/browser/\n')
.exit(0),
ExpectUploadFile(
blocksize=32768,
maxsize=None,
workersrc='Entries',
workdir='wkdir/CVS',
writer=ExpectRemoteRef(remotetransfer.StringFileWriter),
)
.upload_string('/file/1.1/Fri May 17 23:20:00//\nD\n')
.exit(0),
ExpectShell(workdir='wkdir', command=['cvsdiscard', '--ignore'])
.stderr('FAIL!\n')
.exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_worker_connection_lost(self):
self.setup_step(
cvs.CVS(
cvsroot=":pserver:[email protected]:/cvsroot",
cvsmodule="mozilla/browser/",
mode='full',
method='clean',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cvs', '--version']).error(error.ConnectionLost())
)
self.expect_outcome(result=RETRY, state_string="update (retry)")
return self.run_step()
| 59,381 | Python | .py | 1,494 | 25.695448 | 100 | 0.511095 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,485 | test_renderable.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_renderable.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.buildstep import BuildStep
from buildbot.process.properties import Interpolate
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import TestBuildStepMixin
from buildbot.test.util import config as configmixin
class TestBuildStep(BuildStep):
def run(self):
self.setProperty('name', self.name)
return 0
class TestBuildStepNameIsRenderable(
TestBuildStepMixin, unittest.TestCase, TestReactorMixin, configmixin.ConfigErrorsMixin
):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_name_is_renderable(self):
step = TestBuildStep(name=Interpolate('%(kw:foo)s', foo='bar'))
self.setup_step(step)
self.expect_property('name', 'bar')
self.expect_outcome(0)
return self.run_step()
| 1,790 | Python | .py | 41 | 39.731707 | 90 | 0.763929 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,486 | test_maxq.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_maxq.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.steps import maxq
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
class TestShellCommandExecution(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_testdir_required(self):
with self.assertRaises(config.ConfigErrors):
maxq.MaxQ()
def test_success(self):
self.setup_step(maxq.MaxQ(testdir='x'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=["run_maxq.py", "x"])
.stdout('no failures\n')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='success')
return self.run_step()
def test_nonzero_rc_no_failures(self):
self.setup_step(maxq.MaxQ(testdir='x'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=["run_maxq.py", "x"])
.stdout('no failures\n')
.exit(2)
)
self.expect_outcome(result=FAILURE, state_string='1 maxq failures')
return self.run_step()
def test_failures(self):
self.setup_step(maxq.MaxQ(testdir='x'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=["run_maxq.py", "x"])
.stdout('\nTEST FAILURE: foo\n' * 10)
.exit(2)
)
self.expect_outcome(result=FAILURE, state_string='10 maxq failures')
return self.run_step()
| 2,623 | Python | .py | 61 | 36.803279 | 89 | 0.702311 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,487 | test_source_git.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_git.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from parameterized import parameterized
from twisted.internet import defer
from twisted.internet import error
from twisted.trial import unittest
from buildbot import config as bbconfig
from buildbot.interfaces import WorkerSetupError
from buildbot.process import remotetransfer
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.steps.source import git
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectCpdir
from buildbot.test.steps import ExpectDownloadFile
from buildbot.test.steps import ExpectListdir
from buildbot.test.steps import ExpectMkdir
from buildbot.test.steps import ExpectRemoteRef
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.steps import TestBuildStepMixin
from buildbot.test.util import config
from buildbot.test.util import sourcesteps
from buildbot.util import unicode2bytes
from buildbot.util.git_credential import GitCredentialOptions
class TestGit(
sourcesteps.SourceStepMixin, config.ConfigErrorsMixin, TestReactorMixin, unittest.TestCase
):
stepClass = git.Git
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.sourceName = self.stepClass.__name__
return self.setUpSourceStep()
@defer.inlineCallbacks
def tearDown(self):
yield self.tearDownSourceStep()
yield self.tear_down_test_reactor()
def test_mode_full_filters_2_26(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
filters=['tree:0'],
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.26.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_filters_2_27(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
filters=['tree:0'],
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.27.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--filter',
'tree:0',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_progress_False(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
progress=False,
tags=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--tags',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_ssh_key_2_10(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_command_config = f'core.sshCommand=ssh -o "BatchMode=yes" -i "{ssh_key_path}"'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
ssh_command_config,
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_ssh_key_2_3(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_command = f'ssh -o "BatchMode=yes" -i "{ssh_key_path}"'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.3.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
env={'GIT_SSH_COMMAND': ssh_command},
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
@defer.inlineCallbacks
def test_mode_full_clean_ssh_key_1_7(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_wrapper_path = '/wrk/.bldr.wkdir.buildbot/ssh-wrapper.sh'
# A place to store what gets read
read = []
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_wrapper_path,
workdir=ssh_workdir,
mode=0o700,
)
.download_string(read.append)
.exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
env={'GIT_SSH': ssh_wrapper_path},
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
yield self.run_step()
expected = f'#!/bin/sh\nssh -o "BatchMode=yes" -i "{ssh_key_path}" "$@"\n'
self.assertEqual(b''.join(read), unicode2bytes(expected))
@parameterized.expand([
('host_key', {"sshHostKey": 'sshhostkey'}),
('known_hosts', {"sshKnownHosts": 'known_hosts'}),
])
def test_mode_full_clean_ssh_host_key_2_10(self, name, class_params):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
**class_params,
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_known_hosts_path = '/wrk/.bldr.wkdir.buildbot/ssh-known-hosts'
ssh_command_config = (
f'core.sshCommand=ssh -o "BatchMode=yes" -i "{ssh_key_path}" '
f'-o "UserKnownHostsFile={ssh_known_hosts_path}"'
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_known_hosts_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
ssh_command_config,
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_ssh_host_key_2_3(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
sshHostKey='sshhostkey',
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_known_hosts_path = '/wrk/.bldr.wkdir.buildbot/ssh-known-hosts'
ssh_command = (
f'ssh -o "BatchMode=yes" -i "{ssh_key_path}" '
f'-o "UserKnownHostsFile={ssh_known_hosts_path}"'
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.3.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_known_hosts_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
env={'GIT_SSH_COMMAND': ssh_command},
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
@defer.inlineCallbacks
def test_mode_full_clean_ssh_host_key_1_7(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
sshHostKey='sshhostkey',
tags=True,
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_wrapper_path = '/wrk/.bldr.wkdir.buildbot/ssh-wrapper.sh'
ssh_known_hosts_path = '/wrk/.bldr.wkdir.buildbot/ssh-known-hosts'
# A place to store what gets read
read = []
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_known_hosts_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_wrapper_path,
workdir=ssh_workdir,
mode=0o700,
)
.download_string(read.append)
.exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--tags',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
env={'GIT_SSH': ssh_wrapper_path},
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
yield self.run_step()
expected = (
'#!/bin/sh\n'
f'ssh -o "BatchMode=yes" -i "{ssh_key_path}" -o '
f'"UserKnownHostsFile={ssh_known_hosts_path}" "$@"\n'
)
self.assertEqual(b''.join(read), unicode2bytes(expected))
def test_mode_full_clean_ssh_host_key_1_7_progress(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
sshHostKey='sshhostkey',
progress=True,
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_wrapper_path = '/wrk/.bldr.wkdir.buildbot/ssh-wrapper.sh'
ssh_known_hosts_path = '/wrk/.bldr.wkdir.buildbot/ssh-known-hosts'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_known_hosts_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_wrapper_path,
workdir=ssh_workdir,
mode=0o700,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
env={'GIT_SSH': ssh_wrapper_path},
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_ssh_host_key_2_10_abs_workdir(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
sshHostKey='sshhostkey',
),
want_default_work_dir=False,
)
workdir = '/myworkdir/workdir'
self.build.workdir = workdir
ssh_workdir = '/myworkdir/.bldr.workdir.buildbot'
ssh_key_path = '/myworkdir/.bldr.workdir.buildbot/ssh-key'
ssh_known_hosts_path = '/myworkdir/.bldr.workdir.buildbot/ssh-known-hosts'
ssh_command_config = (
f'core.sshCommand=ssh -o "BatchMode=yes" -i "{ssh_key_path}" '
f'-o "UserKnownHostsFile={ssh_known_hosts_path}"'
)
self.expect_commands(
ExpectShell(workdir=workdir, command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='/myworkdir/workdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_known_hosts_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectListdir(dir=workdir).files(['.git']).exit(0),
ExpectShell(workdir=workdir, command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir=workdir,
command=[
'git',
'-c',
ssh_command_config,
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir=workdir, command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir=workdir, command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_win32path(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
)
)
self.change_worker_system('win32')
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file=r'wkdir\.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_win32path_ssh_key_2_10(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
)
)
self.change_worker_system('win32')
ssh_workdir = '\\wrk\\.bldr.wkdir.buildbot'
ssh_key_path = '\\wrk\\.bldr.wkdir.buildbot\\ssh-key'
ssh_command_config = f'core.sshCommand=ssh -o "BatchMode=yes" -i "{ssh_key_path}"'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='wkdir\\.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
ssh_command_config,
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_win32path_ssh_key_2_3(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
)
)
self.change_worker_system('win32')
ssh_workdir = '\\wrk\\.bldr.wkdir.buildbot'
ssh_key_path = '\\wrk\\.bldr.wkdir.buildbot\\ssh-key'
ssh_command = f'ssh -o "BatchMode=yes" -i "{ssh_key_path}"'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.3.0')
.exit(0),
ExpectStat(file='wkdir\\.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
env={'GIT_SSH_COMMAND': ssh_command},
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_win32path_ssh_key_1_7(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
sshPrivateKey='sshkey',
)
)
self.change_worker_system('win32')
ssh_workdir = '\\wrk\\.bldr.wkdir.buildbot'
ssh_key_path = '\\wrk\\.bldr.wkdir.buildbot\\ssh-key'
ssh_wrapper_path = '\\wrk\\.bldr.wkdir.buildbot\\ssh-wrapper.sh'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.0')
.exit(0),
ExpectStat(file='wkdir\\.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_wrapper_path,
workdir=ssh_workdir,
mode=0o700,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
env={'GIT_SSH': ssh_wrapper_path},
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_timeout(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
timeout=1,
mode='full',
method='clean',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', timeout=1, command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir', timeout=1, command=['git', 'clean', '-f', '-f', '-d']
).exit(0),
ExpectShell(
workdir='wkdir',
timeout=1,
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(
workdir='wkdir', timeout=1, command=['git', 'checkout', '-f', 'FETCH_HEAD']
).exit(0),
ExpectShell(workdir='wkdir', timeout=1, command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_patch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x'], log_environ=True
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'update-index', '--refresh']).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'apply', '--index', '-p', '1'],
initial_stdin='patch',
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_patch_worker_2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x'], log_environ=True
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'update-index', '--refresh']).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'apply', '--index', '-p', '1'],
initial_stdin='patch',
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_patch_fail(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'update-index', '--refresh']).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'apply', '--index', '-p', '1'],
initial_stdin='patch',
).exit(1),
)
self.expect_outcome(result=FAILURE)
self.expect_no_property('got_revision')
return self.run_step()
def test_mode_full_clean_branch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
branch='test-branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'test-branch',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-B', 'test-branch']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_tags(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
tags=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--tags',
"--progress",
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_non_empty_builddir(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
branch='test-branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['file1', 'file2']).exit(0),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--branch',
'test-branch',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_parsefail(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD'])
.stderr("fatal: Could not parse object 'b08076bc71c7813038f2cefedff9c5b678d225a8'.\n")
.exit(128),
)
self.expect_outcome(result=FAILURE)
self.expect_no_property('got_revision')
return self.run_step()
def test_mode_full_clean_no_existing_repo(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_no_existing_repo_with_reference(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
reference='path/to/reference/repo',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--reference',
'path/to/reference/repo',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_no_existing_repo_branch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
branch='test-branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--branch',
'test-branch',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_no_existing_repo_with_origin(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
origin='foo',
progress=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--origin',
'foo',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_submodule(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
submodules=True,
progress=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'submodule', 'sync']).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'submodule', 'update', '--init', '--recursive']
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'foreach', '--recursive', 'git clean -f -f -d'],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_submodule_remotes(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clean',
submodules=True,
progress=True,
remoteSubmodules=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'submodule', 'sync']).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'update', '--init', '--recursive', '--remote'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'foreach', '--recursive', 'git clean -f -f -d'],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber_submodule_remotes(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
submodules=True,
progress=True,
remoteSubmodules=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'update', '--init', '--recursive', '--remote'],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
progress=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clone_fails(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
progress=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(1), # clone fails
)
self.expect_outcome(result=FAILURE, state_string="update (failure)")
self.expect_no_property('got_revision')
return self.run_step()
def test_mode_full_clobber_branch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
progress=True,
branch='test-branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--branch',
'test-branch',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber_no_branch_support_shallow(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
branch='test-branch',
shallow=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.5.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--depth',
'1',
'http://github.com/buildbot/buildbot.git',
'.',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--depth',
'1',
'http://github.com/buildbot/buildbot.git',
'test-branch',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-B', 'test-branch']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber_no_branch_support(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
branch='test-branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.5.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'clone', 'http://github.com/buildbot/buildbot.git', '.'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'http://github.com/buildbot/buildbot.git',
'test-branch',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-B', 'test-branch']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_oldworker(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='incremental', progress=True
)
)
self.get_nth_step(0).build.getWorkerCommandVersion = lambda cmd, oldversion: "2.15"
self.expect_commands(
ExpectShell(workdir='wkdir', interrupt_signal='TERM', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.git', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
interrupt_signal='TERM',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(
workdir='wkdir',
interrupt_signal='TERM',
command=['git', 'checkout', '-f', 'FETCH_HEAD'],
).exit(0),
ExpectShell(
workdir='wkdir', interrupt_signal='TERM', command=['git', 'rev-parse', 'HEAD']
)
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='incremental', progress=True
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_version_format(self):
self.setup_step(
self.stepClass(repourl='http://github.com/buildbot/buildbot.git', mode='incremental')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5.1')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_retry(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='incremental', retry=(0, 1)
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_branch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
branch='test-branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'test-branch',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-B', 'test-branch']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_branch_ssh_key_2_10(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
branch='test-branch',
sshPrivateKey='ssh-key',
progress=True,
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_command_config = f'core.sshCommand=ssh -o "BatchMode=yes" -i "{ssh_key_path}"'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
ssh_command_config,
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'test-branch',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-B', 'test-branch']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_no_existing_repo_shallow_submodules(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
shallow=True,
submodules=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--depth',
'1',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'update', '--init', '--recursive', '--depth', '1'],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_fresh(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='fresh'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_fresh_clean_fails(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='fresh'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(
1
), # clean fails -> clobber
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_given_revision(self):
self.setup_step(
self.stepClass(repourl='http://github.com/buildbot/buildbot.git', mode='incremental'),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'cat-file', '-e', 'abcdef01']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'abcdef01']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_given_revision_not_exists(self):
self.setup_step(
self.stepClass(repourl='http://github.com/buildbot/buildbot.git', mode='incremental'),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'cat-file', '-e', 'abcdef01']).exit(1),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'abcdef01']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_fresh_submodule(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='fresh',
submodules=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'submodule', 'sync']).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'submodule', 'update', '--init', '--recursive']
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'foreach', '--recursive', 'git clean -f -f -d -x'],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="update")
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_fresh_submodule_git_newer_1_7_6(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='fresh',
submodules=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.6')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'submodule', 'sync']).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'update', '--init', '--recursive', '--force'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'foreach', '--recursive', 'git clean -f -f -d -x'],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_fresh_submodule_v1_7_8(self):
"""This tests the same as test_mode_full_fresh_submodule, but the
"submodule update" command should be different for Git v1.7.8+."""
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='fresh',
submodules=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.8')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'submodule', 'sync']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'submodule',
'update',
'--init',
'--recursive',
'--force',
'--checkout',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'foreach', '--recursive', 'git clean -f -f -d -x'],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber_shallow(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
shallow=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--depth',
'1',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber_shallow_depth(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
shallow="100",
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--depth',
'100',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber_no_shallow(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clobber'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_retryFetch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
retryFetch=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(1),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_retryFetch_branch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
retryFetch=True,
branch='test-branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'test-branch',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(1),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'test-branch',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-B', 'test-branch']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_clobberOnFailure(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
clobberOnFailure=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_clobberOnFailure_branch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
clobberOnFailure=True,
branch='test-branch',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'test-branch',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--branch',
'test-branch',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_copy(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='copy'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200),
ExpectListdir(dir='source').files(['.git']).exit(0),
ExpectShell(
workdir='source',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='source', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectCpdir(fromdir='source', todir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_copy_ssh_key_2_10(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='copy',
sshPrivateKey='sshkey',
)
)
ssh_workdir = '/wrk/.bldr.source.buildbot'
ssh_key_path = '/wrk/.bldr.source.buildbot/ssh-key'
ssh_command_config = f'core.sshCommand=ssh -o "BatchMode=yes" -i "{ssh_key_path}"'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200),
ExpectListdir(dir='source').files(['.git']).exit(0),
ExpectShell(
workdir='source',
command=[
'git',
'-c',
ssh_command_config,
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='source', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectCpdir(fromdir='source', todir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_copy_shallow(self):
with self.assertRaisesConfigError(
"in mode 'full' shallow only possible with method 'clobber'"
):
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='copy',
shallow=True,
)
def test_mode_incremental_no_existing_repo(self):
self.setup_step(
self.stepClass(repourl='http://github.com/buildbot/buildbot.git', mode='incremental')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_incremental_no_existing_repo_oldworker(self):
self.setup_step(
self.stepClass(repourl='http://github.com/buildbot/buildbot.git', mode='incremental')
)
self.get_nth_step(0).build.getWorkerCommandVersion = lambda cmd, oldversion: "2.15"
self.expect_commands(
ExpectShell(workdir='wkdir', interrupt_signal='TERM', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.git', log_environ=True).exit(1),
ExpectShell(
workdir='wkdir',
interrupt_signal='TERM',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(
workdir='wkdir', interrupt_signal='TERM', command=['git', 'rev-parse', 'HEAD']
)
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber_given_revision(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
progress=True,
),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'abcdef01']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_revparse_failure(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
progress=True,
),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'abcdef01']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ada95a1d') # too short
.exit(0),
)
self.expect_outcome(result=FAILURE)
self.expect_no_property('got_revision')
return self.run_step()
def test_mode_full_clobber_submodule(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
submodules=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'submodule', 'update', '--init', '--recursive']
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clobber_submodule_shallow(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
submodules=True,
shallow='1',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'--depth',
'1',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'submodule', 'update', '--init', '--recursive', '--depth', '1'],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_repourl(self):
with self.assertRaisesConfigError("must provide repourl"):
self.stepClass(mode="full")
def test_mode_full_fresh_revision(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='fresh',
progress=True,
),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'abcdef01']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_fresh_retry(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='fresh',
retry=(0, 2),
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_fresh_clobberOnFailure(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='fresh',
clobberOnFailure=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files().exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_no_method(self):
self.setup_step(
self.stepClass(repourl='http://github.com/buildbot/buildbot.git', mode='full')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_with_env(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', env={'abc': '123'}
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'], env={'abc': '123'})
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'clean', '-f', '-f', '-d', '-x'],
env={'abc': '123'},
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
env={'abc': '123'},
).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD'], env={'abc': '123'}
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'], env={'abc': '123'})
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_log_environ(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', logEnviron=False
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'], log_environ=False)
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=False).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d', '-x'], log_environ=False
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
log_environ=False,
).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD'], log_environ=False
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'], log_environ=False)
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_wkdir_doesnt_exist(self):
self.setup_step(
self.stepClass(repourl='http://github.com/buildbot/buildbot.git', mode='full')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').exit(1),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_getDescription(self):
# clone of: test_mode_incremental
# only difference is to set the getDescription property
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
getDescription=True,
)
)
self.expect_commands(
# copied from test_mode_incremental:
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
# plus this to test describe:
ExpectShell(workdir='wkdir', command=['git', 'describe', 'HEAD'])
.stdout('Tag-1234')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
self.expect_property('commit-description', 'Tag-1234', self.sourceName)
return self.run_step()
def test_getDescription_failed(self):
# clone of: test_mode_incremental
# only difference is to set the getDescription property
# this tests when 'git describe' fails; for example, there are no
# tags in the repository
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='incremental',
getDescription=True,
)
)
self.expect_commands(
# copied from test_mode_incremental:
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
# plus this to test describe:
ExpectShell(workdir='wkdir', command=['git', 'describe', 'HEAD'])
.stdout('')
.exit(128), # error, but it's suppressed
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
self.expect_no_property('commit-description')
return self.run_step()
def setup_getDescription_test(self, setup_args, output_args, expect_head=True, codebase=None):
# clone of: test_mode_full_clobber
# only difference is to set the getDescription property
kwargs = {}
if codebase is not None:
kwargs.update(codebase=codebase)
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='clobber',
progress=True,
getDescription=setup_args,
**kwargs,
)
)
self.expect_commands(
# copied from test_mode_full_clobber:
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
# plus this to test describe:
ExpectShell(
workdir='wkdir',
command=['git', 'describe'] + output_args + (['HEAD'] if expect_head else []),
)
.stdout('Tag-1234')
.exit(0),
)
if codebase:
self.expect_outcome(result=SUCCESS, state_string="update " + codebase)
self.expect_property(
'got_revision',
{codebase: 'f6ad368298bd941e934a41f3babc827b2aa95a1d'},
self.sourceName,
)
self.expect_property('commit-description', {codebase: 'Tag-1234'}, self.sourceName)
else:
self.expect_outcome(result=SUCCESS, state_string="update")
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
self.expect_property('commit-description', 'Tag-1234', self.sourceName)
def test_getDescription_empty_dict(self):
self.setup_getDescription_test(setup_args={}, output_args=[])
return self.run_step()
def test_getDescription_empty_dict_with_codebase(self):
self.setup_getDescription_test(setup_args={}, output_args=[], codebase='baz')
return self.run_step()
def test_getDescription_match(self):
self.setup_getDescription_test(
setup_args={'match': 'stuff-*'}, output_args=['--match', 'stuff-*']
)
return self.run_step()
def test_getDescription_match_false(self):
self.setup_getDescription_test(setup_args={'match': None}, output_args=[])
return self.run_step()
def test_getDescription_exclude(self):
self.setup_getDescription_test(
setup_args={'exclude': 'stuff-*'}, output_args=['--exclude', 'stuff-*']
)
return self.run_step()
def test_getDescription_exclude_false(self):
self.setup_getDescription_test(setup_args={'exclude': None}, output_args=[])
return self.run_step()
def test_getDescription_tags(self):
self.setup_getDescription_test(setup_args={'tags': True}, output_args=['--tags'])
return self.run_step()
def test_getDescription_tags_false(self):
self.setup_getDescription_test(setup_args={'tags': False}, output_args=[])
return self.run_step()
def test_getDescription_all(self):
self.setup_getDescription_test(setup_args={'all': True}, output_args=['--all'])
return self.run_step()
def test_getDescription_all_false(self):
self.setup_getDescription_test(setup_args={'all': False}, output_args=[])
return self.run_step()
def test_getDescription_abbrev(self):
self.setup_getDescription_test(setup_args={'abbrev': 7}, output_args=['--abbrev=7'])
return self.run_step()
def test_getDescription_abbrev_zero(self):
self.setup_getDescription_test(setup_args={'abbrev': 0}, output_args=['--abbrev=0'])
return self.run_step()
def test_getDescription_abbrev_false(self):
self.setup_getDescription_test(setup_args={'abbrev': False}, output_args=[])
return self.run_step()
def test_getDescription_dirty(self):
self.setup_getDescription_test(
setup_args={'dirty': True}, output_args=['--dirty'], expect_head=False
)
return self.run_step()
def test_getDescription_dirty_empty_str(self):
self.setup_getDescription_test(
setup_args={'dirty': ''}, output_args=['--dirty'], expect_head=False
)
return self.run_step()
def test_getDescription_dirty_str(self):
self.setup_getDescription_test(
setup_args={'dirty': 'foo'}, output_args=['--dirty=foo'], expect_head=False
)
return self.run_step()
def test_getDescription_dirty_false(self):
self.setup_getDescription_test(
setup_args={'dirty': False}, output_args=[], expect_head=True
)
return self.run_step()
def test_getDescription_dirty_none(self):
self.setup_getDescription_test(setup_args={'dirty': None}, output_args=[], expect_head=True)
return self.run_step()
def test_getDescription_contains(self):
self.setup_getDescription_test(setup_args={'contains': True}, output_args=['--contains'])
return self.run_step()
def test_getDescription_contains_false(self):
self.setup_getDescription_test(setup_args={'contains': False}, output_args=[])
return self.run_step()
def test_getDescription_candidates(self):
self.setup_getDescription_test(setup_args={'candidates': 7}, output_args=['--candidates=7'])
return self.run_step()
def test_getDescription_candidates_zero(self):
self.setup_getDescription_test(setup_args={'candidates': 0}, output_args=['--candidates=0'])
return self.run_step()
def test_getDescription_candidates_false(self):
self.setup_getDescription_test(setup_args={'candidates': False}, output_args=[])
return self.run_step()
def test_getDescription_exact_match(self):
self.setup_getDescription_test(
setup_args={'exact-match': True}, output_args=['--exact-match']
)
return self.run_step()
def test_getDescription_exact_match_false(self):
self.setup_getDescription_test(setup_args={'exact-match': False}, output_args=[])
return self.run_step()
def test_getDescription_first_parent(self):
self.setup_getDescription_test(
setup_args={'first-parent': True}, output_args=['--first-parent']
)
return self.run_step()
def test_getDescription_first_parent_false(self):
self.setup_getDescription_test(setup_args={'first-parent': False}, output_args=[])
return self.run_step()
def test_getDescription_debug(self):
self.setup_getDescription_test(setup_args={'debug': True}, output_args=['--debug'])
return self.run_step()
def test_getDescription_debug_false(self):
self.setup_getDescription_test(setup_args={'debug': False}, output_args=[])
return self.run_step()
def test_getDescription_long(self):
self.setup_getDescription_test(setup_args={'long': True}, output_args=['--long'])
def test_getDescription_long_false(self):
self.setup_getDescription_test(setup_args={'long': False}, output_args=[])
return self.run_step()
def test_getDescription_always(self):
self.setup_getDescription_test(setup_args={'always': True}, output_args=['--always'])
def test_getDescription_always_false(self):
self.setup_getDescription_test(setup_args={'always': False}, output_args=[])
return self.run_step()
def test_getDescription_lotsa_stuff(self):
self.setup_getDescription_test(
setup_args={'match': 'stuff-*', 'abbrev': 6, 'exact-match': True},
output_args=['--exact-match', '--match', 'stuff-*', '--abbrev=6'],
codebase='baz',
)
return self.run_step()
def test_config_option(self):
name = 'url.http://github.com.insteadOf'
value = 'blahblah'
self.setup_step(
self.stepClass(
repourl=f'{value}/buildbot/buildbot.git',
mode='full',
method='clean',
config={name: value},
)
)
prefix = ['git', '-c', f'{name}={value}']
self.expect_commands(
ExpectShell(workdir='wkdir', command=[*prefix, '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=[*prefix, 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
*prefix,
'fetch',
'-f',
'--progress',
f'{value}/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=[*prefix, 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=[*prefix, 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_worker_connection_lost(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.error(error.ConnectionLost())
)
self.expect_outcome(result=RETRY, state_string="update (retry)")
return self.run_step()
@defer.inlineCallbacks
def _test_WorkerSetupError(self, _dovccmd, step, msg):
self.patch(self.stepClass, "_dovccmd", _dovccmd)
gitStep = self.setup_step(step)
with self.assertRaisesRegex(WorkerSetupError, msg):
yield gitStep.run_vc("branch", "revision", "patch")
def test_noGitCommandInstalled(self):
@defer.inlineCallbacks
def _dovccmd(command, abandonOnFailure=True, collectStdout=False, initialStdin=None):
"""
Simulate the case where there is no git command.
"""
yield
return "command not found:"
step = self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
)
msg = 'git is not installed on worker'
return self._test_WorkerSetupError(_dovccmd, step, msg)
def test_gitCommandOutputShowsNoVersion(self):
@defer.inlineCallbacks
def _dovccmd(command, abandonOnFailure=True, collectStdout=False, initialStdin=None):
"""
Instead of outputting something like "git version 2.11",
simulate truncated output which has no version string,
to exercise error handling.
"""
yield
return "git "
step = self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
)
msg = 'git is not installed on worker'
return self._test_WorkerSetupError(_dovccmd, step, msg)
def test_config_get_description_not_dict_or_boolean(self):
with self.assertRaisesConfigError("Git: getDescription must be a boolean or a dict."):
self.stepClass(
repourl="http://github.com/buildbot/buildbot.git", getDescription=["list"]
)
def test_config_invalid_method_with_full(self):
with self.assertRaisesConfigError("Git: invalid method for mode 'full'."):
self.stepClass(
repourl="http://github.com/buildbot/buildbot.git", mode='full', method='unknown'
)
def test_mode_full_copy_recursive(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='copy',
submodules='True',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200),
ExpectListdir(dir='source').files(['.git']).exit(0),
ExpectShell(
workdir='source',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='source', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='source', command=['git', 'submodule', 'sync']).exit(0),
ExpectShell(
workdir='source', command=['git', 'submodule', 'update', '--init', '--recursive']
).exit(0),
ExpectCpdir(fromdir='source', todir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_copy_recursive_fetch_fail(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='copy',
submodules='True',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200),
ExpectListdir(dir='source').files(['.git']).exit(0),
ExpectShell(
workdir='source',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_mode_full_copy_recursive_fetch_fail_retry_fail(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='copy',
submodules='True',
retryFetch=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200),
ExpectListdir(dir='source').files(['.git']).exit(0),
ExpectShell(
workdir='source',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(1),
ExpectShell(
workdir='source',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_mode_full_copy_recursive_fetch_fail_retry_succeed(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='copy',
submodules='True',
retryFetch=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200),
ExpectListdir(dir='source').files(['.git']).exit(0),
ExpectShell(
workdir='source',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(1),
# retry Fetch
ExpectShell(
workdir='source',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(0),
# continue as normal
ExpectShell(workdir='source', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='source', command=['git', 'submodule', 'sync']).exit(0),
ExpectShell(
workdir='source', command=['git', 'submodule', 'update', '--init', '--recursive']
).exit(0),
ExpectCpdir(fromdir='source', todir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_copy_recursive_fetch_fail_clobberOnFailure(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git',
mode='full',
method='copy',
submodules='True',
clobberOnFailure=True,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True, timeout=1200),
ExpectListdir(dir='source').files(['.git']).exit(0),
ExpectShell(
workdir='source',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'HEAD',
],
).exit(1),
# clobber and re-clone the source dir here
ExpectRmdir(dir='source', log_environ=True, timeout=1200).exit(0),
ExpectShell(
workdir='source',
command=[
'git',
'clone',
'http://github.com/buildbot/buildbot.git',
'.',
'--progress',
],
).exit(0),
ExpectShell(
workdir='source', command=['git', 'submodule', 'update', '--init', '--recursive']
).exit(0),
ExpectShell(workdir='source', command=['git', 'submodule', 'sync']).exit(0),
ExpectShell(
workdir='source', command=['git', 'submodule', 'update', '--init', '--recursive']
).exit(0),
ExpectCpdir(fromdir='source', todir='wkdir', log_environ=True, timeout=1200).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
@parameterized.expand([
('', None),
('use_http_path', True),
('dont_use_http_path', False),
])
def test_mode_full_clean_auth_credential(self, name, use_http_path):
self.setup_step(
self.stepClass(
repourl='https://example.com/test/test.git',
mode='full',
method='clean',
auth_credentials=('username', 'token'),
git_credentials=GitCredentialOptions(
credentials=[],
use_http_path=use_http_path,
),
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
git_credential_path = '/wrk/.bldr.wkdir.buildbot/.git-credentials'
use_http_path_arg = []
if use_http_path is not None:
use_http_path_arg.append('-c')
if use_http_path:
use_http_path_arg.append('credential.useHttpPath=true')
else:
use_http_path_arg.append('credential.useHttpPath=false')
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
*use_http_path_arg,
'credential',
'approve',
],
initial_stdin=(
"url=https://example.com/test/test.git\n"
"username=username\n"
"password=token\n"
),
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
*use_http_path_arg,
'fetch',
'-f',
'--progress',
'https://example.com/test/test.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_git_credential(self):
self.setup_step(
self.stepClass(
repourl='https://example.com/test/test.git',
mode='full',
method='clean',
git_credentials=GitCredentialOptions(
credentials=[
(
"url=https://example.com/test/test.git\n"
"username=username\n"
"password=token\n"
),
],
),
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
git_credential_path = '/wrk/.bldr.wkdir.buildbot/.git-credentials'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
'credential',
'approve',
],
initial_stdin=(
"url=https://example.com/test/test.git\n"
"username=username\n"
"password=token\n"
),
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
'fetch',
'-f',
'--progress',
'https://example.com/test/test.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
def test_mode_full_clean_auth_and_git_credential(self):
self.setup_step(
self.stepClass(
repourl='https://example.com/test/test.git',
mode='full',
method='clean',
auth_credentials=('auth_username', 'auth_token'),
git_credentials=GitCredentialOptions(
credentials=[
(
"url=https://example.com/test/submodule_test.git\n"
"username=username\n"
"password=token\n"
),
],
use_http_path=True,
),
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
git_credential_path = '/wrk/.bldr.wkdir.buildbot/.git-credentials'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
'-c',
'credential.useHttpPath=true',
'credential',
'approve',
],
initial_stdin=(
"url=https://example.com/test/test.git\n"
"username=auth_username\n"
"password=auth_token\n"
),
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
'-c',
'credential.useHttpPath=true',
'credential',
'approve',
],
initial_stdin=(
"url=https://example.com/test/submodule_test.git\n"
"username=username\n"
"password=token\n"
),
).exit(0),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
'-c',
'credential.useHttpPath=true',
'fetch',
'-f',
'--progress',
'https://example.com/test/test.git',
'HEAD',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property(
'got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', self.sourceName
)
return self.run_step()
class TestGitPush(
TestBuildStepMixin, config.ConfigErrorsMixin, TestReactorMixin, unittest.TestCase
):
stepClass = git.GitPush
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
def tearDown(self):
return self.tear_down_test_build_step()
def test_push_simple(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(self.stepClass(workdir='wkdir', repourl=url, branch='testbranch'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'push', url, 'testbranch']).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_push_force(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(
self.stepClass(workdir='wkdir', repourl=url, branch='testbranch', force=True)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'push', url, 'testbranch', '--force']
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_push_fail(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(
self.stepClass(workdir='wkdir', repourl=url, branch='testbranch', force=True)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'push', url, 'testbranch', '--force'])
.stderr("error: failed to push some refs to <url>\n")
.exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_push_ssh_key_2_10(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(
self.stepClass(
workdir='wkdir', repourl=url, branch='testbranch', sshPrivateKey='sshKey'
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_command_config = f'core.sshCommand=ssh -o "BatchMode=yes" -i "{ssh_key_path}"'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', '-c', ssh_command_config, 'push', url, 'testbranch'],
).exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_push_ssh_key_2_3(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(
self.stepClass(
workdir='wkdir', repourl=url, branch='testbranch', sshPrivateKey='sshKey'
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_command = f'ssh -o "BatchMode=yes" -i "{ssh_key_path}"'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.3.0')
.exit(0),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'push', url, 'testbranch'],
env={'GIT_SSH_COMMAND': ssh_command},
).exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_push_ssh_key_1_7(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(
self.stepClass(
workdir='wkdir', repourl=url, branch='testbranch', sshPrivateKey='sshKey'
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_wrapper_path = '/wrk/.bldr.wkdir.buildbot/ssh-wrapper.sh'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.0')
.exit(0),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_wrapper_path,
workdir=ssh_workdir,
mode=0o700,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'push', url, 'testbranch'],
env={'GIT_SSH': ssh_wrapper_path},
).exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_push_ssh_host_key_2_10(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(
self.stepClass(
workdir='wkdir',
repourl=url,
branch='testbranch',
sshPrivateKey='sshkey',
sshHostKey='sshhostkey',
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_known_hosts_path = '/wrk/.bldr.wkdir.buildbot/ssh-known-hosts'
ssh_command_config = (
f'core.sshCommand=ssh -o "BatchMode=yes" -i "{ssh_key_path}" '
f'-o "UserKnownHostsFile={ssh_known_hosts_path}"'
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.10.0')
.exit(0),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_known_hosts_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', '-c', ssh_command_config, 'push', url, 'testbranch'],
).exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_push_ssh_host_key_2_3(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(
self.stepClass(
workdir='wkdir',
repourl=url,
branch='testbranch',
sshPrivateKey='sshkey',
sshHostKey='sshhostkey',
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_known_hosts_path = '/wrk/.bldr.wkdir.buildbot/ssh-known-hosts'
ssh_command = (
f'ssh -o "BatchMode=yes" -i "{ssh_key_path}" '
f'-o "UserKnownHostsFile={ssh_known_hosts_path}"'
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 2.3.0')
.exit(0),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_known_hosts_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'push', url, 'testbranch'],
env={'GIT_SSH_COMMAND': ssh_command},
).exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_push_ssh_host_key_1_7(self):
url = 'ssh://github.com/test/test.git'
self.setup_step(
self.stepClass(
workdir='wkdir',
repourl=url,
branch='testbranch',
sshPrivateKey='sshkey',
sshHostKey='sshhostkey',
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
ssh_key_path = '/wrk/.bldr.wkdir.buildbot/ssh-key'
ssh_wrapper_path = '/wrk/.bldr.wkdir.buildbot/ssh-wrapper.sh'
ssh_known_hosts_path = '/wrk/.bldr.wkdir.buildbot/ssh-known-hosts'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.0')
.exit(0),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_key_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_known_hosts_path,
workdir=ssh_workdir,
mode=0o400,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest=ssh_wrapper_path,
workdir=ssh_workdir,
mode=0o700,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'push', url, 'testbranch'],
env={'GIT_SSH': ssh_wrapper_path},
).exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_raise_no_git(self):
@defer.inlineCallbacks
def _checkFeatureSupport(self):
yield
return False
url = 'ssh://github.com/test/test.git'
step = self.stepClass(workdir='wkdir', repourl=url, branch='testbranch')
self.patch(self.stepClass, "checkFeatureSupport", _checkFeatureSupport)
self.setup_step(step)
self.expect_outcome(result=EXCEPTION)
self.run_step()
self.flushLoggedErrors(WorkerSetupError)
def test_config_fail_no_branch(self):
with self.assertRaisesConfigError("GitPush: must provide branch"):
self.stepClass(workdir='wkdir', repourl="url")
@parameterized.expand([
('', None),
('use_http_path', True),
('dont_use_http_path', False),
])
def test_push_auth_credential(self, name, use_http_path):
url = 'https://example.com/test/test.git'
self.setup_step(
self.stepClass(
workdir='wkdir',
repourl=url,
branch='testbranch',
auth_credentials=('username', 'token'),
git_credentials=GitCredentialOptions(
credentials=[],
use_http_path=use_http_path,
),
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
git_credential_path = '/wrk/.bldr.wkdir.buildbot/.git-credentials'
use_http_path_arg = []
if use_http_path is not None:
use_http_path_arg.append('-c')
if use_http_path:
use_http_path_arg.append('credential.useHttpPath=true')
else:
use_http_path_arg.append('credential.useHttpPath=false')
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.9')
.exit(0),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
*use_http_path_arg,
'credential',
'approve',
],
initial_stdin=(
"url=https://example.com/test/test.git\n"
"username=username\n"
"password=token\n"
),
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
*use_http_path_arg,
'push',
url,
'testbranch',
],
).exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_push_git_credential(self):
url = 'https://example.com/test/test.git'
self.setup_step(
self.stepClass(
workdir='wkdir',
repourl=url,
branch='testbranch',
git_credentials=GitCredentialOptions(
credentials=[
(
"url=https://example.com/test/test.git\n"
"username=username\n"
"password=token\n"
),
]
),
)
)
ssh_workdir = '/wrk/.bldr.wkdir.buildbot'
git_credential_path = '/wrk/.bldr.wkdir.buildbot/.git-credentials'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.9')
.exit(0),
ExpectMkdir(dir=ssh_workdir, log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
'credential',
'approve',
],
initial_stdin=(
"url=https://example.com/test/test.git\n"
"username=username\n"
"password=token\n"
),
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'git',
'-c',
'credential.helper=',
'-c',
f'credential.helper=store "--file={git_credential_path}"',
'push',
url,
'testbranch',
],
).exit(0),
ExpectRmdir(dir=ssh_workdir, log_environ=True).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
class TestGitTag(TestBuildStepMixin, config.ConfigErrorsMixin, TestReactorMixin, unittest.TestCase):
stepClass = git.GitTag
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
def tearDown(self):
return self.tear_down_test_build_step()
def test_tag_annotated(self):
messages = ['msg1', 'msg2']
self.setup_step(
self.stepClass(workdir='wkdir', tagName='myTag', annotated=True, messages=messages)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'tag', '-a', 'myTag', '-m', 'msg1', '-m', 'msg2']
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_tag_simple(self):
self.setup_step(self.stepClass(workdir='wkdir', tagName='myTag'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'tag', 'myTag']).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_tag_force(self):
self.setup_step(self.stepClass(workdir='wkdir', tagName='myTag', force=True))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'tag', 'myTag', '--force']).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_tag_fail_already_exist(self):
self.setup_step(self.stepClass(workdir='wkdir', tagName='myTag'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'tag', 'myTag'])
.stderr("fatal: tag '%s' already exist\n")
.exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_config_annotated_no_messages(self):
with self.assertRaises(bbconfig.ConfigErrors):
self.setup_step(self.stepClass(workdir='wkdir', tagName='myTag', annotated=True))
def test_config_no_tag_name(self):
with self.assertRaises(bbconfig.ConfigErrors):
self.setup_step(self.stepClass(workdir='wkdir'))
def test_config_not_annotated_but_meessages(self):
with self.assertRaises(bbconfig.ConfigErrors):
self.setup_step(self.stepClass(workdir='wkdir', tagName='myTag', messages=['msg']))
def test_config_annotated_message_not_list(self):
with self.assertRaises(bbconfig.ConfigErrors):
self.setup_step(
self.stepClass(workdir='wkdir', tagName='myTag', annotated=True, messages="msg")
)
def test_raise_no_git(self):
@defer.inlineCallbacks
def _checkFeatureSupport(self):
yield
return False
step = self.stepClass(workdir='wdir', tagName='myTag')
self.patch(self.stepClass, "checkFeatureSupport", _checkFeatureSupport)
self.setup_step(step)
self.expect_outcome(result=EXCEPTION)
self.run_step()
self.flushLoggedErrors(WorkerSetupError)
class TestGitCommit(
TestBuildStepMixin, config.ConfigErrorsMixin, TestReactorMixin, unittest.TestCase
):
stepClass = git.GitCommit
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
self.message_list = ['my commit', '42']
self.path_list = ['file1.txt', 'file2.txt']
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_add_fail(self):
self.setup_step(
self.stepClass(workdir='wkdir', paths=self.path_list, messages=self.message_list)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('refs/head/myBranch')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'add', 'file1.txt', 'file2.txt']).exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_commit(self):
self.setup_step(
self.stepClass(workdir='wkdir', paths=self.path_list, messages=self.message_list)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('refs/head/myBranch')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'add', 'file1.txt', 'file2.txt']).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'commit', '-m', 'my commit', '-m', '42']
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_commit_noverify(self):
self.setup_step(
self.stepClass(
workdir='wkdir', paths=self.path_list, messages=self.message_list, no_verify=True
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('refs/head/myBranch')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'add', 'file1.txt', 'file2.txt']).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'commit', '-m', 'my commit', '-m', '42', '--no-verify'],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_commit_empty_disallow(self):
self.setup_step(
self.stepClass(
workdir='wkdir',
paths=self.path_list,
messages=self.message_list,
emptyCommits='disallow',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('refs/head/myBranch')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'add', 'file1.txt', 'file2.txt']).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'commit', '-m', 'my commit', '-m', '42']
).exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_commit_empty_allow(self):
self.setup_step(
self.stepClass(
workdir='wkdir',
paths=self.path_list,
messages=self.message_list,
emptyCommits='create-empty-commit',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('refs/head/myBranch')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'add', 'file1.txt', 'file2.txt']).exit(0),
ExpectShell(
workdir='wkdir',
command=['git', 'commit', '-m', 'my commit', '-m', '42', '--allow-empty'],
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_commit_empty_ignore_withcommit(self):
self.setup_step(
self.stepClass(
workdir='wkdir',
paths=self.path_list,
messages=self.message_list,
emptyCommits='ignore',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('refs/head/myBranch')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'add', 'file1.txt', 'file2.txt']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'status', '--porcelain=v1'])
.stdout('MM file2.txt\n?? file3.txt')
.exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'commit', '-m', 'my commit', '-m', '42']
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_commit_empty_ignore_withoutcommit(self):
self.setup_step(
self.stepClass(
workdir='wkdir',
paths=self.path_list,
messages=self.message_list,
emptyCommits='ignore',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('refs/head/myBranch')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'add', 'file1.txt', 'file2.txt']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'status', '--porcelain=v1'])
.stdout('?? file3.txt')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_commit_empty_ignore_witherror(self):
self.setup_step(
self.stepClass(
workdir='wkdir',
paths=self.path_list,
messages=self.message_list,
emptyCommits='ignore',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('refs/head/myBranch')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'add', 'file1.txt', 'file2.txt']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'status', '--porcelain=v1']).exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_detached_head(self):
self.setup_step(
self.stepClass(workdir='wkdir', paths=self.path_list, messages=self.message_list)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectShell(workdir='wkdir', command=['git', 'symbolic-ref', 'HEAD'])
.stdout('')
.exit(1),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_config_no_files_arg(self):
with self.assertRaisesConfigError("GitCommit: must provide paths"):
self.stepClass(workdir='wkdir', messages=self.message_list)
def test_config_files_not_a_list(self):
with self.assertRaisesConfigError("GitCommit: paths must be a list"):
self.stepClass(workdir='wkdir', paths="test.txt", messages=self.message_list)
def test_config_no_messages_arg(self):
with self.assertRaisesConfigError("GitCommit: must provide messages"):
self.stepClass(workdir='wkdir', paths=self.path_list)
def test_config_messages_not_a_list(self):
with self.assertRaisesConfigError("GitCommit: messages must be a list"):
self.stepClass(workdir='wkdir', paths=self.path_list, messages="my message")
def test_raise_no_git(self):
@defer.inlineCallbacks
def _checkFeatureSupport(self):
yield
return False
step = self.stepClass(workdir='wkdir', paths=self.path_list, messages=self.message_list)
self.patch(self.stepClass, "checkFeatureSupport", _checkFeatureSupport)
self.setup_step(step)
self.expect_outcome(result=EXCEPTION)
self.run_step()
self.flushLoggedErrors(WorkerSetupError)
| 193,872 | Python | .py | 4,724 | 27.280059 | 100 | 0.508712 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,488 | test_package_deb_lintian.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_package_deb_lintian.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process.results import SUCCESS
from buildbot.steps.package.deb import lintian
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
class TestDebLintian(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_no_fileloc(self):
with self.assertRaises(config.ConfigErrors):
lintian.DebLintian()
def test_success(self):
self.setup_step(lintian.DebLintian('foo_0.23_i386.changes'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['lintian', '-v', 'foo_0.23_i386.changes']).exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="Lintian")
return self.run_step()
def test_success_suppressTags(self):
self.setup_step(
lintian.DebLintian(
'foo_0.23_i386.changes', suppressTags=['bad-distribution-in-changes-file']
)
)
self.expect_commands(
ExpectShell(
workdir='wkdir',
command=[
'lintian',
'-v',
'foo_0.23_i386.changes',
'--suppress-tags',
'bad-distribution-in-changes-file',
],
).exit(0)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
| 2,493 | Python | .py | 60 | 33.95 | 100 | 0.676289 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,489 | test_source_github.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_github.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from buildbot.process.results import SUCCESS
from buildbot.steps.source import github
from buildbot.test.steps import ExpectListdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.unit.steps import test_source_git
# GitHub step shall behave exactly like Git, and thus is inheriting its tests
class TestGitHub(test_source_git.TestGit):
stepClass = github.GitHub
def test_with_merge_branch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
),
{"branch": 'refs/pull/1234/merge', "revision": '12345678'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
# here we always ignore revision, and fetch the merge branch
ExpectShell(
workdir='wkdir',
command=[
'git',
'fetch',
'-f',
'--progress',
'http://github.com/buildbot/buildbot.git',
'refs/pull/1234/merge',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', 'FETCH_HEAD']).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'checkout', '-B', 'refs/pull/1234/merge']
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', 'GitHub')
return self.run_step()
def test_with_head_branch(self):
self.setup_step(
self.stepClass(
repourl='http://github.com/buildbot/buildbot.git', mode='full', method='clean'
),
{"branch": 'refs/pull/1234/head', "revision": '12345678'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['git', '--version'])
.stdout('git version 1.7.5')
.exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectListdir(dir='wkdir').files(['.git']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'clean', '-f', '-f', '-d']).exit(0),
# in the case of the head, we try to find if the head is already present
# and reset to that without fetching
ExpectShell(workdir='wkdir', command=['git', 'cat-file', '-e', '12345678']).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'checkout', '-f', '12345678']).exit(0),
ExpectShell(
workdir='wkdir', command=['git', 'checkout', '-B', 'refs/pull/1234/head']
).exit(0),
ExpectShell(workdir='wkdir', command=['git', 'rev-parse', 'HEAD'])
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', 'f6ad368298bd941e934a41f3babc827b2aa95a1d', 'GitHub')
return self.run_step()
| 4,331 | Python | .py | 88 | 39.181818 | 98 | 0.609537 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,490 | test_package_rpm_rpmlint.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_package_rpm_rpmlint.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.results import SUCCESS
from buildbot.steps.package.rpm import rpmlint
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
class TestRpmLint(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_success(self):
self.setup_step(rpmlint.RpmLint())
self.expect_commands(ExpectShell(workdir='wkdir', command=['rpmlint', '-i', '.']).exit(0))
self.expect_outcome(result=SUCCESS, state_string='Finished checking RPM/SPEC issues')
return self.run_step()
def test_fileloc_success(self):
self.setup_step(rpmlint.RpmLint(fileloc='RESULT'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['rpmlint', '-i', 'RESULT']).exit(0)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_config_success(self):
self.setup_step(rpmlint.RpmLint(config='foo.cfg'))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['rpmlint', '-i', '-f', 'foo.cfg', '.']).exit(0)
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
| 2,256 | Python | .py | 48 | 41.833333 | 98 | 0.726364 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,491 | test_cppcheck.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_cppcheck.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.properties import WithProperties
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.steps import cppcheck
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
class Cppcheck(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_success(self):
self.setup_step(cppcheck.Cppcheck(enable=['all'], inconclusive=True))
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['cppcheck', '.', '--enable=all', '--inconclusive']
)
.stdout('Checking file1.c...')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="cppcheck")
return self.run_step()
def test_command_failure(self):
self.setup_step(cppcheck.Cppcheck(enable=['all'], inconclusive=True))
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['cppcheck', '.', '--enable=all', '--inconclusive']
)
.stdout('Checking file1.c...')
.exit(1)
)
self.expect_outcome(result=FAILURE, state_string="cppcheck (failure)")
return self.run_step()
def test_warnings(self):
self.setup_step(cppcheck.Cppcheck(source=['file1.c'], enable=['warning', 'performance']))
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['cppcheck', 'file1.c', '--enable=warning,performance']
)
.stdout(
'Checking file1.c...\n'
'[file1.c:3]: (warning) Logical disjunction always '
'evaluates to true: t >= 0 || t < 65.\n'
'(information) Cppcheck cannot find all the include files '
'(use --check-config for details)'
)
.exit(0)
)
self.expect_outcome(
result=WARNINGS, state_string="cppcheck warning=1 information=1 (warnings)"
)
return self.run_step()
def test_errors(self):
self.setup_step(cppcheck.Cppcheck(extra_args=['--my-param=5']))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['cppcheck', '.', '--my-param=5'])
.stdout(
'Checking file1.c...\n'
'[file1.c:3]: (error) Possible null pointer dereference: filter\n'
'[file1.c:4]: (error) Memory leak: columns\n'
"[file1.c:7]: (style) The scope of the variable 'pid' can be reduced"
)
.exit(0)
)
self.expect_outcome(result=FAILURE, state_string="cppcheck error=2 style=1 (failure)")
return self.run_step()
def test_renderables(self):
P = WithProperties
self.setup_step(
cppcheck.Cppcheck(
binary=P('a'), source=[P('.'), P('f.c')], extra_args=[P('--p'), P('--p')]
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['a', '.', 'f.c', '--p', '--p'])
.stdout('Checking file1.c...')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="cppcheck")
return self.run_step()
| 4,395 | Python | .py | 101 | 34.772277 | 97 | 0.626751 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,492 | test_master.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_master.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import os
import pprint
import sys
from twisted.internet import defer
from twisted.python import runtime
from twisted.trial import unittest
from buildbot.process.properties import Interpolate
from buildbot.process.properties import Property
from buildbot.process.properties import renderer
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.steps import master
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectMasterShell
from buildbot.test.steps import TestBuildStepMixin
_COMSPEC_ENV = 'COMSPEC'
class TestMasterShellCommand(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
if runtime.platformType == 'win32':
self.comspec = os.environ.get(_COMSPEC_ENV)
os.environ[_COMSPEC_ENV] = r'C:\WINDOWS\system32\cmd.exe'
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
if runtime.platformType == 'win32':
if self.comspec:
os.environ[_COMSPEC_ENV] = self.comspec
else:
del os.environ[_COMSPEC_ENV]
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_constr_args(self):
self.setup_step(
master.MasterShellCommand(
description='x',
descriptionDone='y',
env={'a': 'b'},
workdir='build',
usePTY=True,
command='true',
)
)
if runtime.platformType == 'win32':
exp_argv = [r'C:\WINDOWS\system32\cmd.exe', '/c', 'true']
else:
exp_argv = ['/bin/sh', '-c', 'true']
self.expect_commands(
ExpectMasterShell(exp_argv)
.workdir('build')
.env({'a': 'b'})
.stdout(b'hello!\n')
.stderr(b'world\n')
.exit(0)
)
self.expect_log_file('stdio', "hello!\n")
self.expect_outcome(result=SUCCESS, state_string='y')
return self.run_step()
@defer.inlineCallbacks
def test_env_subst(self):
os.environ['WORLD'] = 'hello'
self.setup_step(master.MasterShellCommand(command='true', env={'HELLO': '${WORLD}'}))
if runtime.platformType == 'win32':
exp_argv = [r'C:\WINDOWS\system32\cmd.exe', '/c', 'true']
else:
exp_argv = ['/bin/sh', '-c', 'true']
self.expect_commands(ExpectMasterShell(exp_argv).env({'HELLO': 'hello'}).exit(0))
self.expect_outcome(result=SUCCESS)
try:
yield self.run_step()
finally:
del os.environ['WORLD']
@defer.inlineCallbacks
def test_env_list_subst(self):
os.environ['WORLD'] = 'hello'
os.environ['LIST'] = 'world'
self.setup_step(
master.MasterShellCommand(command='true', env={'HELLO': ['${WORLD}', '${LIST}']})
)
if sys.platform == 'win32':
exp_argv = [r'C:\WINDOWS\system32\cmd.exe', '/c', 'true']
exp_env = 'hello;world'
else:
exp_argv = ['/bin/sh', '-c', 'true']
exp_env = 'hello:world'
self.expect_commands(ExpectMasterShell(exp_argv).env({'HELLO': exp_env}).exit(0))
self.expect_outcome(result=SUCCESS)
try:
yield self.run_step()
finally:
del os.environ['WORLD']
del os.environ['LIST']
def test_prop_rendering(self):
self.setup_step(
master.MasterShellCommand(
command=Interpolate('%(prop:project)s-BUILD'), workdir='build'
)
)
self.build.setProperty("project", "BUILDBOT-TEST", "TEST")
if runtime.platformType == 'win32':
exp_argv = [r'C:\WINDOWS\system32\cmd.exe', '/c', 'BUILDBOT-TEST-BUILD']
else:
exp_argv = ['/bin/sh', '-c', 'BUILDBOT-TEST-BUILD']
self.expect_commands(ExpectMasterShell(exp_argv).workdir('build').exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_constr_args_descriptionSuffix(self):
self.setup_step(
master.MasterShellCommand(
description='x',
descriptionDone='y',
descriptionSuffix='z',
env={'a': 'b'},
workdir='build',
usePTY=True,
command='true',
)
)
if runtime.platformType == 'win32':
exp_argv = [r'C:\WINDOWS\system32\cmd.exe', '/c', 'true']
else:
exp_argv = ['/bin/sh', '-c', 'true']
self.expect_commands(ExpectMasterShell(exp_argv).workdir('build').env({'a': 'b'}).exit(0))
self.expect_outcome(result=SUCCESS, state_string='y z')
return self.run_step()
class TestSetProperty(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_simple(self):
self.setup_step(
master.SetProperty(
property="testProperty",
value=Interpolate("sch=%(prop:scheduler)s, worker=%(prop:workername)s"),
)
)
self.build.setProperty('scheduler', 'force', source='SetProperty', runtime=True)
self.build.setProperty('workername', 'testWorker', source='SetProperty', runtime=True)
self.expect_outcome(result=SUCCESS, state_string="Set")
self.expect_property('testProperty', 'sch=force, worker=testWorker', source='SetProperty')
return self.run_step()
class TestLogRenderable(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_simple(self):
self.setup_step(
master.LogRenderable(
content=Interpolate('sch=%(prop:scheduler)s, worker=%(prop:workername)s')
)
)
self.build.setProperty("scheduler", "force", source="TestSetProperty", runtime=True)
self.build.setProperty("workername", "testWorker", source="TestSetProperty", runtime=True)
self.expect_outcome(result=SUCCESS, state_string='Logged')
self.expect_log_file('Output', pprint.pformat('sch=force, worker=testWorker'))
return self.run_step()
class TestsSetProperties(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def doOneTest(self, **kwargs):
# all three tests should create a 'a' property with 'b' value, all with different
# more or less dynamic methods
self.setup_step(master.SetProperties(name="my-step", **kwargs))
self.expect_property('a', 'b', 'my-step')
self.expect_outcome(result=SUCCESS, state_string='Properties Set')
return self.run_step()
def test_basic(self):
return self.doOneTest(properties={'a': 'b'})
def test_renderable(self):
return self.doOneTest(properties={'a': Interpolate("b")})
def test_renderer(self):
@renderer
def manipulate(props):
# the renderer returns renderable!
return {'a': Interpolate('b')}
return self.doOneTest(properties=manipulate)
class TestAssert(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_eq_pass(self):
self.setup_step(master.Assert(Property("test_prop") == "foo"))
self.build.setProperty("test_prop", "foo", "bar")
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_eq_fail(self):
self.setup_step(master.Assert(Property("test_prop") == "bar"))
self.build.setProperty("test_prop", "foo", "bar")
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_renderable_pass(self):
@renderer
def test_renderer(props):
return props.getProperty("test_prop") == "foo"
self.setup_step(master.Assert(test_renderer))
self.build.setProperty("test_prop", "foo", "bar")
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_renderable_fail(self):
@renderer
def test_renderer(props):
return props.getProperty("test_prop") == "bar"
self.setup_step(master.Assert(test_renderer))
self.build.setProperty("test_prop", "foo", "bar")
self.expect_outcome(result=FAILURE)
return self.run_step()
| 10,153 | Python | .py | 237 | 33.983122 | 98 | 0.632732 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,493 | test_source_bzr.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_bzr.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import os
from twisted.internet import defer
from twisted.internet import error
from twisted.python.reflect import namedModule
from twisted.trial import unittest
from buildbot.process import remotetransfer
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.steps.source import bzr
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectCpdir
from buildbot.test.steps import ExpectDownloadFile
from buildbot.test.steps import ExpectRemoteRef
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.util import sourcesteps
class TestBzr(sourcesteps.SourceStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setUpSourceStep()
@defer.inlineCallbacks
def tearDown(self):
yield self.tearDownSourceStep()
yield self.tear_down_test_reactor()
def test_mode_full(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='fresh'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'clean-tree', '--force']).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="update")
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_win32path(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='fresh'
)
)
self.build.path_module = namedModule('ntpath')
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file=r'wkdir\.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file=r'wkdir\.bzr', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'clean-tree', '--force']).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_timeout(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk',
mode='full',
method='fresh',
timeout=1,
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', timeout=1, command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', timeout=1, command=['bzr', 'clean-tree', '--force']).exit(
0
),
ExpectShell(workdir='wkdir', timeout=1, command=['bzr', 'update']).exit(0),
ExpectShell(
workdir='wkdir',
timeout=1,
command=['bzr', 'version-info', '--custom', "--template='{revno}"],
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_revision(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='fresh'
),
args={"revision": '3730'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'clean-tree', '--force']).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update', '-r', '3730']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clean(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='clean'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'clean-tree', '--ignored', '--force']
).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clean_patched(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='clean'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
# clean up the applied patch
ExpectShell(
workdir='wkdir', command=['bzr', 'clean-tree', '--ignored', '--force']
).exit(0),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
# this clean is from 'mode=clean'
ExpectShell(
workdir='wkdir', command=['bzr', 'clean-tree', '--ignored', '--force']
).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clean_patch(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='clean'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'clean-tree', '--ignored', '--force']
).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update']).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.FileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.FileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'patch',
'-p1',
'--remove-empty-files',
'--force',
'--forward',
'-i',
'.buildbot-diff',
],
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clean_patch_worker_2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='clean'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'clean-tree', '--ignored', '--force']
).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update']).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.FileReader),
slavedest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.FileReader),
slavedest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'patch',
'-p1',
'--remove-empty-files',
'--force',
'--forward',
'-i',
'.buildbot-diff',
],
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clean_revision(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='clean'
),
args={"revision": '2345'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'clean-tree', '--ignored', '--force']
).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update', '-r', '2345']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_fresh(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='fresh'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'clean-tree', '--force']).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clobber(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='clobber'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clobber_retry(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk',
mode='full',
method='clobber',
retry=(0, 2),
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clobber_revision(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='clobber'
),
args={"revision": '3730'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'bzr',
'checkout',
'http://bzr.squid-cache.org/bzr/squid3/trunk',
'.',
'-r',
'3730',
],
).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clobber_baseurl(self):
self.setup_step(
bzr.Bzr(
baseURL='http://bzr.squid-cache.org/bzr/squid3',
defaultBranch='trunk',
mode='full',
method='clobber',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'bzr',
'checkout',
os.path.join('http://bzr.squid-cache.org/bzr/squid3', 'trunk'),
'.',
],
).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_clobber_baseurl_nodefault(self):
self.setup_step(
bzr.Bzr(
baseURL='http://bzr.squid-cache.org/bzr/squid3',
defaultBranch='trunk',
mode='full',
method='clobber',
),
args={"branch": 'branches/SQUID_3_0'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'bzr',
'checkout',
os.path.join('http://bzr.squid-cache.org/bzr/squid3', 'branches/SQUID_3_0'),
'.',
],
).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_full_copy(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='copy'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='build', log_environ=True).exit(0),
ExpectStat(file='source/.bzr', log_environ=True).exit(0),
ExpectShell(workdir='source', command=['bzr', 'update']).exit(0),
ExpectCpdir(fromdir='source', log_environ=True, todir='build').exit(0),
ExpectShell(
workdir='source', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_incremental(self):
self.setup_step(
bzr.Bzr(repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='incremental')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_incremental_revision(self):
self.setup_step(
bzr.Bzr(repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='incremental'),
args={"revision": '9384'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(0),
ExpectShell(workdir='wkdir', command=['bzr', 'update', '-r', '9384']).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100', 'Bzr')
return self.run_step()
def test_mode_incremental_no_existing_repo(self):
self.setup_step(
bzr.Bzr(repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='incremental')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(1),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100\n')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100\n', 'Bzr')
return self.run_step()
def test_mode_incremental_retry(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk',
mode='incremental',
retry=(0, 1),
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(1),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('100\n')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
self.expect_property('got_revision', '100\n', 'Bzr')
return self.run_step()
def test_bad_revparse(self):
self.setup_step(
bzr.Bzr(repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='incremental')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(1),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['bzr', 'version-info', '--custom', "--template='{revno}"]
)
.stdout('oiasdfj010laksjfd')
.exit(0),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_bad_checkout(self):
self.setup_step(
bzr.Bzr(repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='incremental')
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.bzr', log_environ=True).exit(1),
ExpectShell(
workdir='wkdir',
command=['bzr', 'checkout', 'http://bzr.squid-cache.org/bzr/squid3/trunk', '.'],
)
.stderr('failed\n')
.exit(128),
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_worker_connection_lost(self):
self.setup_step(
bzr.Bzr(
repourl='http://bzr.squid-cache.org/bzr/squid3/trunk', mode='full', method='fresh'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['bzr', '--version']).error(error.ConnectionLost())
)
self.expect_outcome(result=RETRY, state_string="update (retry)")
return self.run_step()
| 27,559 | Python | .py | 646 | 30.475232 | 100 | 0.534613 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,494 | test_source_mercurial.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_source_mercurial.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.internet import error
from twisted.python.reflect import namedModule
from twisted.trial import unittest
from buildbot import config
from buildbot.process import remotetransfer
from buildbot.process.results import FAILURE
from buildbot.process.results import RETRY
from buildbot.process.results import SUCCESS
from buildbot.steps.source import mercurial
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectDownloadFile
from buildbot.test.steps import ExpectRemoteRef
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import ExpectStat
from buildbot.test.util import sourcesteps
class TestMercurial(sourcesteps.SourceStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setUpSourceStep()
@defer.inlineCallbacks
def tearDown(self):
yield self.tearDownSourceStep()
yield self.tear_down_test_reactor()
def patch_workerVersionIsOlderThan(self, result):
self.patch(mercurial.Mercurial, 'workerVersionIsOlderThan', lambda x, y, z: result)
def test_no_repourl(self):
with self.assertRaises(config.ConfigErrors):
mercurial.Mercurial(mode="full")
def test_incorrect_mode(self):
with self.assertRaises(config.ConfigErrors):
mercurial.Mercurial(repourl='http://hg.mozilla.org', mode='invalid')
def test_incorrect_method(self):
with self.assertRaises(config.ConfigErrors):
mercurial.Mercurial(repourl='http://hg.mozilla.org', method='invalid')
def test_incorrect_branchType(self):
with self.assertRaises(config.ConfigErrors):
mercurial.Mercurial(repourl='http://hg.mozilla.org', branchType='invalid')
def test_mode_full_clean(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='clean', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_win32path(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='clean', branchType='inrepo'
)
)
self.build.path_module = namedModule('ntpath')
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file=r'wkdir\.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file=r'wkdir\.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_timeout(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org',
timeout=1,
mode='full',
method='clean',
branchType='inrepo',
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', timeout=1, command=['hg', '--verbose', '--version']).exit(
0
),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
timeout=1,
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge'],
).exit(0),
ExpectShell(
workdir='wkdir',
timeout=1,
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', timeout=1, command=['hg', '--verbose', 'identify', '--branch']
)
.stdout('default')
.exit(0),
ExpectShell(
workdir='wkdir', timeout=1, command=['hg', '--verbose', 'locate', 'set:added()']
).exit(1),
ExpectShell(
workdir='wkdir',
timeout=1,
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir',
timeout=1,
command=['hg', '--verbose', 'parents', '--template', '{node}\\n'],
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_patch(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='clean', branchType='inrepo'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'import', '--no-commit', '-p', '1', '-'],
initial_stdin='patch',
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_patch_worker_2_16(self):
self.setup_build(worker_version={'*': '2.16'})
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='clean', branchType='inrepo'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
slavedest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'import', '--no-commit', '-p', '1', '-'],
initial_stdin='patch',
).exit(0),
ExpectRmdir(dir='wkdir/.buildbot-diff', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_patch_fail(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='clean', branchType='inrepo'
),
patch=(1, 'patch'),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(0),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-diff',
workdir='wkdir',
mode=None,
).exit(0),
ExpectDownloadFile(
blocksize=32768,
maxsize=None,
reader=ExpectRemoteRef(remotetransfer.StringFileReader),
workerdest='.buildbot-patched',
workdir='wkdir',
mode=None,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'import', '--no-commit', '-p', '1', '-'],
initial_stdin='patch',
).exit(1),
)
self.expect_outcome(result=FAILURE, state_string="update (failure)")
return self.run_step()
def test_mode_full_clean_no_existing_repo(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='clean', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(1),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
log_environ=True,
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clobber(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='clobber', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_fresh(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='fresh', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge', '--all'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_fresh_no_existing_repo(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='fresh', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(1),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
log_environ=True,
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_fresh_retry(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org',
mode='full',
method='fresh',
branchType='inrepo',
retry=(0, 2),
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(1),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
log_environ=True,
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_no_existing_repo_dirname(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='incremental', branchType='dirname'
),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(1), # does not exist
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'update', '--clean']).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_retry(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org',
mode='incremental',
branchType='dirname',
retry=(0, 1),
),
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(1), # does not exist
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(1),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'update', '--clean']).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_branch_change_dirname(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org/',
mode='incremental',
branchType='dirname',
defaultBranch='devel',
),
{"branch": 'stable'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org/stable']
).exit(0),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'hg',
'--verbose',
'clone',
'--noupdate',
'http://hg.mozilla.org/stable',
'.',
],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'update', '--clean']).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_no_existing_repo_inrepo(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='incremental', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(1), # does not exist
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_existing_repo(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='incremental', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0), # directory exists
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_existing_repo_added_files(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='incremental', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0), # directory exists
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()'])
.stdout('foo\nbar/baz\n')
.exit(1),
ExpectRmdir(dir=['wkdir/foo', 'wkdir/bar/baz'], log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_existing_repo_added_files_old_rmdir(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='incremental', branchType='inrepo'
)
)
self.patch_workerVersionIsOlderThan(True)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0), # directory exists
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()'])
.stdout('foo\nbar/baz\n')
.exit(1),
ExpectRmdir(dir='wkdir/foo', log_environ=True).exit(0),
ExpectRmdir(dir='wkdir/bar/baz', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_given_revision(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='incremental', branchType='inrepo'
),
{"revision": 'abcdef01'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'abcdef01'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'abcdef01'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_branch_change(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='incremental', branchType='inrepo'
),
{"branch": 'stable'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'stable'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectRmdir(dir='wkdir', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'clone', '--noupdate', 'http://hg.mozilla.org', '.'],
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'update', '--clean', '--rev', 'stable']
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_incremental_branch_change_no_clobberOnBranchChange(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org',
mode='incremental',
branchType='inrepo',
clobberOnBranchChange=False,
),
{"branch": 'stable'},
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'stable'],
).exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'identify', '--branch'])
.stdout('default')
.exit(0),
ExpectShell(workdir='wkdir', command=['hg', '--verbose', 'locate', 'set:added()']).exit(
1
),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'update', '--clean', '--rev', 'stable']
).exit(0),
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', 'parents', '--template', '{node}\\n']
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_env(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org',
mode='full',
method='clean',
branchType='inrepo',
env={'abc': '123'},
)
)
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', '--version'], env={'abc': '123'}
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=True).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=True).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge'],
env={'abc': '123'},
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
env={'abc': '123'},
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'identify', '--branch'],
env={'abc': '123'},
)
.stdout('default')
.exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'locate', 'set:added()'],
env={'abc': '123'},
).exit(1),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
env={'abc': '123'},
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'parents', '--template', '{node}\\n'],
env={'abc': '123'},
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_mode_full_clean_log_environ(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org',
mode='full',
method='clean',
branchType='inrepo',
logEnviron=False,
)
)
self.expect_commands(
ExpectShell(
workdir='wkdir', command=['hg', '--verbose', '--version'], log_environ=False
).exit(0),
ExpectStat(file='wkdir/.buildbot-patched', log_environ=False).exit(1),
ExpectStat(file='wkdir/.hg', log_environ=False).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', '--config', 'extensions.purge=', 'purge'],
log_environ=False,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'pull', 'http://hg.mozilla.org', '--rev', 'default'],
log_environ=False,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'identify', '--branch'],
log_environ=False,
)
.stdout('default')
.exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'locate', 'set:added()'],
log_environ=False,
).exit(1),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'update', '--clean', '--rev', 'default'],
log_environ=False,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['hg', '--verbose', 'parents', '--template', '{node}\\n'],
log_environ=False,
)
.stdout('\n')
.stdout('f6ad368298bd941e934a41f3babc827b2aa95a1d')
.exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_command_fails(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='fresh', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).exit(1)
)
self.expect_outcome(result=FAILURE)
return self.run_step()
def test_worker_connection_lost(self):
self.setup_step(
mercurial.Mercurial(
repourl='http://hg.mozilla.org', mode='full', method='clean', branchType='inrepo'
)
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['hg', '--verbose', '--version']).error(
error.ConnectionLost()
)
)
self.expect_outcome(result=RETRY, state_string="update (retry)")
return self.run_step()
| 42,566 | Python | .py | 987 | 30.232016 | 100 | 0.509881 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,495 | test_python.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_python.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from parameterized import parameterized
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.process.results import WARNINGS
from buildbot.steps import python
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
log_output_success = """\
Making output directory...
Running Sphinx v1.0.7
loading pickled environment... not yet created
No builder selected, using default: html
building [html]: targets for 24 source files that are out of date
updating environment: 24 added, 0 changed, 0 removed
reading sources... [ 4%] index
reading sources... [ 8%] manual/cfg-builders
...
copying static files... done
dumping search index... done
dumping object inventory... done
build succeeded.
"""
log_output_nochange = """\
Running Sphinx v1.0.7
loading pickled environment... done
No builder selected, using default: html
building [html]: targets for 0 source files that are out of date
updating environment: 0 added, 0 changed, 0 removed
looking for now-outdated files... none found
no targets are out of date.
"""
log_output_warnings = """\
Running Sphinx v1.0.7
loading pickled environment... done
building [html]: targets for 1 source files that are out of date
updating environment: 0 added, 1 changed, 0 removed
reading sources... [100%] file
file.rst:18: (WARNING/2) Literal block expected; none found.
looking for now-outdated files... none found
pickling environment... done
checking consistency... done
preparing documents... done
writing output... [ 50%] index
writing output... [100%] file
index.rst:: WARNING: toctree contains reference to document 'preamble' that \
doesn't have a title: no link will be generated
writing additional files... search
copying static files... done
dumping search index... done
dumping object inventory... done
build succeeded, 2 warnings."""
log_output_warnings_strict = """\
Running Sphinx v1.0.7
loading pickled environment... done
building [html]: targets for 1 source files that are out of date
updating environment: 0 added, 1 changed, 0 removed
reading sources... [100%] file
Warning, treated as error:
file.rst:18:Literal block expected; none found.
"""
warnings = """\
file.rst:18: (WARNING/2) Literal block expected; none found.
index.rst:: WARNING: toctree contains reference to document 'preamble' that \
doesn't have a title: no link will be generated\
"""
# this is from a run of epydoc against the buildbot source..
epydoc_output = """\
[...............
+---------------------------------------------------------------------
| In /home/dustin/code/buildbot/t/buildbot/master/buildbot/
| ec2.py:
| Import failed (but source code parsing was successful).
| Error: ImportError: No module named boto (line 19)
|
[....
Warning: Unable to extract the base list for
twisted.web.resource.EncodingResourceWrapper: Bad dotted name
[......
+---------------------------------------------------------------------
| In /home/dustin/code/buildbot/t/buildbot/master/buildbot/worker/
| ec2.py:
| Import failed (but source code parsing was successful).
| Error: ImportError: No module named boto (line 28)
|
[...........
+---------------------------------------------------------------------
| In /home/dustin/code/buildbot/t/buildbot/master/buildbot/status/
| status_push.py:
| Import failed (but source code parsing was successful).
| Error: ImportError: No module named status_json (line 40)
|
[....................<paragraph>Special descriptor for class __provides__</paragraph>
"""
class BuildEPYDoc(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_sample(self):
self.setup_step(python.BuildEPYDoc())
self.expect_commands(
ExpectShell(workdir='wkdir', command=['make', 'epydocs']).stdout(epydoc_output).exit(1),
)
self.expect_outcome(result=FAILURE, state_string='epydoc warn=1 err=3 (failure)')
return self.run_step()
class PyLint(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
@parameterized.expand([('no_results', True), ('with_results', False)])
def test_success(self, name, store_results):
self.setup_step(python.PyLint(command=['pylint'], store_results=store_results))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout('Your code has been rated at 10/10')
.exit(python.PyLint.RC_OK)
)
self.expect_outcome(result=SUCCESS, state_string='pylint')
if store_results:
self.expect_test_result_sets([('Pylint warnings', 'code_issue', 'message')])
self.expect_test_results([])
return self.run_step()
@parameterized.expand([('no_results', True), ('with_results', False)])
def test_error(self, name, store_results):
self.setup_step(python.PyLint(command=['pylint'], store_results=store_results))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(
'W: 11: Bad indentation. Found 6 spaces, expected 4\n'
'E: 12: Undefined variable \'foo\'\n'
)
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_ERROR)
)
self.expect_outcome(result=FAILURE, state_string='pylint error=1 warning=1 (failure)')
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-error', 1)
if store_results:
self.expect_test_result_sets([('Pylint warnings', 'code_issue', 'message')])
# note that no results are submitted for tests where we don't know the location
return self.run_step()
def test_header_output(self):
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.log('stdio', header='W: 11: Bad indentation. Found 6 spaces, expected 4\n')
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string='pylint')
return self.run_step()
def test_failure(self):
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(
'W: 11: Bad indentation. Found 6 spaces, expected 4\n'
'F: 13: something really strange happened\n'
)
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_FATAL)
)
self.expect_outcome(result=FAILURE, state_string='pylint fatal=1 warning=1 (failure)')
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-fatal', 1)
return self.run_step()
def test_failure_zero_returncode(self):
# Make sure that errors result in a failed step when pylint's
# return code is 0, e.g. when run through a wrapper script.
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(
'W: 11: Bad indentation. Found 6 spaces, expected 4\n'
'E: 12: Undefined variable \'foo\'\n'
)
.exit(0)
)
self.expect_outcome(result=FAILURE, state_string='pylint error=1 warning=1 (failure)')
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-error', 1)
return self.run_step()
def test_regex_text(self):
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(
'W: 11: Bad indentation. Found 6 spaces, expected 4\n'
'C: 1:foo123: Missing docstring\n'
)
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
return self.run_step()
def test_regex_text_0_24(self):
# pylint >= 0.24.0 prints out column offsets when using text format
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(
'W: 11,0: Bad indentation. Found 6 spaces, expected 4\n'
'C: 3,10:foo123: Missing docstring\n'
)
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
return self.run_step()
def test_regex_text_1_3_1(self):
# at least pylint 1.3.1 prints out space padded column offsets when
# using text format
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(
'W: 11, 0: Bad indentation. Found 6 spaces, expected 4\n'
'C: 3,10:foo123: Missing docstring\n'
)
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
return self.run_step()
@parameterized.expand([('no_results', True), ('with_results', False)])
def test_regex_text_2_0_0(self, name, store_results):
# pylint 2.0.0 changed default format to include file path
self.setup_step(python.PyLint(command=['pylint'], store_results=store_results))
stdout = (
'test.py:9:4: W0311: Bad indentation. Found 6 spaces, expected 4 (bad-indentation)\n'
+ 'test.py:1:0: C0114: Missing module docstring (missing-module-docstring)\n'
)
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(stdout)
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
if store_results:
self.expect_test_result_sets([('Pylint warnings', 'code_issue', 'message')])
self.expect_test_results([
(
1000,
'test.py:9:4: W0311: Bad indentation. Found 6 spaces, expected 4 '
+ '(bad-indentation)',
None,
'test.py',
9,
None,
),
(
1000,
'test.py:1:0: C0114: Missing module docstring (missing-module-docstring)',
None,
'test.py',
1,
None,
),
])
return self.run_step()
def test_regex_text_2_0_0_invalid_line(self):
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
stdout = 'test.py:abc:0: C0114: Missing module docstring (missing-module-docstring)\n'
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(stdout)
.exit(python.PyLint.RC_CONVENTION)
)
self.expect_outcome(result=SUCCESS, state_string='pylint')
self.expect_property('pylint-warning', 0)
self.expect_property('pylint-convention', 0)
self.expect_property('pylint-total', 0)
return self.run_step()
def test_regex_text_ids(self):
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout('W0311: 11: Bad indentation.\nC0111: 1:funcName: Missing docstring\n')
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
return self.run_step()
def test_regex_text_ids_0_24(self):
# pylint >= 0.24.0 prints out column offsets when using text format
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout('W0311: 11,0: Bad indentation.\nC0111: 3,10:foo123: Missing docstring\n')
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
return self.run_step()
@parameterized.expand([('no_results', True), ('with_results', False)])
def test_regex_parseable_ids(self, name, store_results):
self.setup_step(python.PyLint(command=['pylint'], store_results=store_results))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(
'test.py:9: [W0311] Bad indentation.\n'
'test.py:3: [C0111, foo123] Missing docstring\n'
)
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
if store_results:
self.expect_test_result_sets([('Pylint warnings', 'code_issue', 'message')])
self.expect_test_results([
(1000, 'test.py:9: [W0311] Bad indentation.', None, 'test.py', 9, None),
(1000, 'test.py:3: [C0111, foo123] Missing docstring', None, 'test.py', 3, None),
])
return self.run_step()
def test_regex_parseable(self):
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout('test.py:9: [W] Bad indentation.\ntest.py:3: [C, foo123] Missing docstring\n')
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
return self.run_step()
def test_regex_parseable_1_3_1(self):
"""In pylint 1.3.1, output parseable is deprecated, but looks like
that, this is also the new recommended format string:
--msg-template={path}:{line}: [{msg_id}({symbol}), {obj}] {msg}
"""
self.setup_step(python.PyLint(command=['pylint'], store_results=False))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['pylint'])
.stdout(
'test.py:9: [W0311(bad-indentation), ] '
'Bad indentation. Found 6 '
'spaces, expected 4\n'
'test.py:3: [C0111(missing-docstring), myFunc] Missing '
'function docstring\n'
)
.exit(python.PyLint.RC_WARNING | python.PyLint.RC_CONVENTION)
)
self.expect_outcome(
result=WARNINGS, state_string='pylint convention=1 warning=1 (warnings)'
)
self.expect_property('pylint-warning', 1)
self.expect_property('pylint-convention', 1)
self.expect_property('pylint-total', 2)
return self.run_step()
class PyFlakes(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_success(self):
self.setup_step(python.PyFlakes())
self.expect_commands(ExpectShell(workdir='wkdir', command=['make', 'pyflakes']).exit(0))
self.expect_outcome(result=SUCCESS, state_string='pyflakes')
return self.run_step()
def test_content_in_header(self):
self.setup_step(python.PyFlakes())
self.expect_commands(
ExpectShell(workdir='wkdir', command=['make', 'pyflakes'])
# don't match pyflakes-like output in the header
.log('stdio', header="foo.py:1: 'bar' imported but unused\n")
.exit(0)
)
self.expect_outcome(result=0, state_string='pyflakes')
return self.run_step()
def test_unused(self):
self.setup_step(python.PyFlakes())
self.expect_commands(
ExpectShell(workdir='wkdir', command=['make', 'pyflakes'])
.stdout("foo.py:1: 'bar' imported but unused\n")
.exit(1)
)
self.expect_outcome(result=WARNINGS, state_string='pyflakes unused=1 (warnings)')
self.expect_property('pyflakes-unused', 1)
self.expect_property('pyflakes-total', 1)
return self.run_step()
def test_undefined(self):
self.setup_step(python.PyFlakes())
self.expect_commands(
ExpectShell(workdir='wkdir', command=['make', 'pyflakes'])
.stdout("foo.py:1: undefined name 'bar'\n")
.exit(1)
)
self.expect_outcome(result=FAILURE, state_string='pyflakes undefined=1 (failure)')
self.expect_property('pyflakes-undefined', 1)
self.expect_property('pyflakes-total', 1)
return self.run_step()
def test_redefs(self):
self.setup_step(python.PyFlakes())
self.expect_commands(
ExpectShell(workdir='wkdir', command=['make', 'pyflakes'])
.stdout("foo.py:2: redefinition of unused 'foo' from line 1\n")
.exit(1)
)
self.expect_outcome(result=WARNINGS, state_string='pyflakes redefs=1 (warnings)')
self.expect_property('pyflakes-redefs', 1)
self.expect_property('pyflakes-total', 1)
return self.run_step()
def test_importstar(self):
self.setup_step(python.PyFlakes())
self.expect_commands(
ExpectShell(workdir='wkdir', command=['make', 'pyflakes'])
.stdout("foo.py:1: 'from module import *' used; unable to detect undefined names\n")
.exit(1)
)
self.expect_outcome(result=WARNINGS, state_string='pyflakes import*=1 (warnings)')
self.expect_property('pyflakes-import*', 1)
self.expect_property('pyflakes-total', 1)
return self.run_step()
def test_misc(self):
self.setup_step(python.PyFlakes())
self.expect_commands(
ExpectShell(workdir='wkdir', command=['make', 'pyflakes'])
.stdout("foo.py:2: redefinition of function 'bar' from line 1\n")
.exit(1)
)
self.expect_outcome(result=WARNINGS, state_string='pyflakes misc=1 (warnings)')
self.expect_property('pyflakes-misc', 1)
self.expect_property('pyflakes-total', 1)
return self.run_step()
class TestSphinx(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_builddir_required(self):
with self.assertRaises(config.ConfigErrors):
python.Sphinx()
def test_bad_mode(self):
with self.assertRaises(config.ConfigErrors):
python.Sphinx(sphinx_builddir="_build", mode="don't care")
def test_success(self):
self.setup_step(python.Sphinx(sphinx_builddir="_build"))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['sphinx-build', '.', '_build'])
.stdout(log_output_success)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="sphinx 0 warnings")
return self.run_step()
def test_failure(self):
self.setup_step(python.Sphinx(sphinx_builddir="_build"))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['sphinx-build', '.', '_build'])
.stdout('oh noes!')
.exit(1)
)
self.expect_outcome(result=FAILURE, state_string="sphinx 0 warnings (failure)")
return self.run_step()
def test_strict_warnings(self):
self.setup_step(python.Sphinx(sphinx_builddir="_build", strict_warnings=True))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['sphinx-build', '-W', '.', '_build'])
.stdout(log_output_warnings_strict)
.exit(1)
)
self.expect_outcome(result=FAILURE, state_string="sphinx 1 warnings (failure)")
return self.run_step()
def test_nochange(self):
self.setup_step(python.Sphinx(sphinx_builddir="_build"))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['sphinx-build', '.', '_build'])
.stdout(log_output_nochange)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="sphinx 0 warnings")
return self.run_step()
@defer.inlineCallbacks
def test_warnings(self):
self.setup_step(python.Sphinx(sphinx_builddir="_build"))
self.expect_commands(
ExpectShell(workdir='wkdir', command=['sphinx-build', '.', '_build'])
.stdout(log_output_warnings)
.exit(0)
)
self.expect_outcome(result=WARNINGS, state_string="sphinx 2 warnings (warnings)")
self.expect_log_file("warnings", warnings)
yield self.run_step()
self.assertEqual(self.get_nth_step(0).statistics, {'warnings': 2})
def test_constr_args(self):
self.setup_step(
python.Sphinx(
sphinx_sourcedir='src',
sphinx_builddir="bld",
sphinx_builder='css',
sphinx="/path/to/sphinx-build",
tags=['a', 'b'],
strict_warnings=True,
defines={"empty": None, "t": True, "f": False, "s": 'str'},
mode='full',
)
)
self.expect_commands(
ExpectShell(
workdir='wkdir',
command=[
'/path/to/sphinx-build',
'-b',
'css',
'-t',
'a',
'-t',
'b',
'-D',
'empty',
'-D',
'f=0',
'-D',
's=str',
'-D',
't=1',
'-E',
'-W',
'src',
'bld',
],
)
.stdout(log_output_success)
.exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="sphinx 0 warnings")
return self.run_step()
| 25,885 | Python | .py | 586 | 34.982935 | 100 | 0.616268 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,496 | test_package_rpm_mock.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_package_rpm_mock.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot import config
from buildbot.process.properties import Interpolate
from buildbot.process.results import SUCCESS
from buildbot.steps.package.rpm import mock
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectRmdir
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
class TestMock(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
def tearDown(self):
return self.tear_down_test_build_step()
def test_no_root(self):
with self.assertRaises(config.ConfigErrors):
mock.Mock()
def test_class_attrs(self):
step = self.setup_step(mock.Mock(root='TESTROOT'))
self.assertEqual(step.command, ['mock', '--root', 'TESTROOT'])
def test_success(self):
self.setup_step(mock.Mock(root='TESTROOT'))
self.expect_commands(
ExpectRmdir(
dir=['build/build.log', 'build/root.log', 'build/state.log'], log_environ=False
).exit(0),
ExpectShell(
workdir='wkdir',
command=['mock', '--root', 'TESTROOT'],
logfiles={
'build.log': 'build.log',
'root.log': 'root.log',
'state.log': 'state.log',
},
).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="'mock --root ...'")
return self.run_step()
def test_resultdir_success(self):
self.setup_step(mock.Mock(root='TESTROOT', resultdir='RESULT'))
self.expect_commands(
ExpectRmdir(
dir=['build/RESULT/build.log', 'build/RESULT/root.log', 'build/RESULT/state.log'],
log_environ=False,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['mock', '--root', 'TESTROOT', '--resultdir', 'RESULT'],
logfiles={
'build.log': 'RESULT/build.log',
'root.log': 'RESULT/root.log',
'state.log': 'RESULT/state.log',
},
).exit(0),
)
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_resultdir_renderable(self):
resultdir_text = "RESULT"
self.setup_step(
mock.Mock(
root='TESTROOT', resultdir=Interpolate('%(kw:resultdir)s', resultdir=resultdir_text)
)
)
self.expect_commands(
ExpectRmdir(
dir=['build/RESULT/build.log', 'build/RESULT/root.log', 'build/RESULT/state.log'],
log_environ=False,
).exit(0),
ExpectShell(
workdir='wkdir',
command=['mock', '--root', 'TESTROOT', '--resultdir', 'RESULT'],
logfiles={
'build.log': 'RESULT/build.log',
'root.log': 'RESULT/root.log',
'state.log': 'RESULT/state.log',
},
).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string="'mock --root ...'")
return self.run_step()
class TestMockBuildSRPM(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_no_spec(self):
with self.assertRaises(config.ConfigErrors):
mock.MockBuildSRPM(root='TESTROOT')
def test_success(self):
self.setup_step(mock.MockBuildSRPM(root='TESTROOT', spec="foo.spec"))
self.expect_commands(
ExpectRmdir(
dir=['build/build.log', 'build/root.log', 'build/state.log'], log_environ=False
).exit(0),
ExpectShell(
workdir='wkdir',
command=[
'mock',
'--root',
'TESTROOT',
'--buildsrpm',
'--spec',
'foo.spec',
'--sources',
'.',
],
logfiles={
'build.log': 'build.log',
'root.log': 'root.log',
'state.log': 'state.log',
},
).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string='mock buildsrpm')
return self.run_step()
class TestMockRebuild(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_no_srpm(self):
with self.assertRaises(config.ConfigErrors):
mock.MockRebuild(root='TESTROOT')
def test_success(self):
self.setup_step(mock.MockRebuild(root='TESTROOT', srpm="foo.src.rpm"))
self.expect_commands(
ExpectRmdir(
dir=['build/build.log', 'build/root.log', 'build/state.log'], log_environ=False
).exit(0),
ExpectShell(
workdir='wkdir',
command=['mock', '--root', 'TESTROOT', '--rebuild', 'foo.src.rpm'],
logfiles={
'build.log': 'build.log',
'root.log': 'root.log',
'state.log': 'state.log',
},
).exit(0),
)
self.expect_outcome(result=SUCCESS, state_string='mock rebuild srpm')
return self.run_step()
| 6,729 | Python | .py | 164 | 29.932927 | 100 | 0.574637 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,497 | test_trigger.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_trigger.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from __future__ import annotations
from unittest.mock import Mock
from twisted.internet import defer
from twisted.internet import reactor
from twisted.python import failure
from twisted.trial import unittest
from zope.interface import implementer
from buildbot import config
from buildbot import interfaces
from buildbot.process import properties
from buildbot.process.results import CANCELLED
from buildbot.process.results import EXCEPTION
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.steps import trigger
from buildbot.test import fakedb
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import TestBuildStepMixin
from buildbot.test.util.interfaces import InterfaceTests
@implementer(interfaces.ITriggerableScheduler)
class FakeTriggerable:
triggered_with = None
result = SUCCESS
bsid = 1
brids: dict[int, int] = {}
exception = False
never_finish = False
def __init__(self, name):
self.name = name
def trigger(
self,
waited_for,
sourcestamps=None,
set_props=None,
parent_buildid=None,
parent_relationship=None,
):
self.triggered_with = (waited_for, sourcestamps, set_props.properties)
idsDeferred = defer.Deferred()
idsDeferred.callback((self.bsid, self.brids))
resultsDeferred = defer.Deferred()
if not self.never_finish:
if self.exception:
reactor.callLater(0, resultsDeferred.errback, RuntimeError('oh noes'))
else:
reactor.callLater(0, resultsDeferred.callback, (self.result, self.brids))
return (idsDeferred, resultsDeferred)
class TriggerableInterfaceTest(unittest.TestCase, InterfaceTests):
def test_interface(self):
self.assertInterfacesImplemented(FakeTriggerable)
class FakeSourceStamp:
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
def asDict(self, includePatch=True):
return self.__dict__.copy()
class FakeSchedulerManager:
pass
# Magic numbers that relate brid to other build settings
def BRID_TO_BSID(brid):
return brid + 2000
def BRID_TO_BID(brid):
return brid + 3000
def BRID_TO_BUILD_NUMBER(brid):
return brid + 4000
class TestTrigger(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
@defer.inlineCallbacks
def setup_step(self, step, sourcestampsInBuild=None, gotRevisionsInBuild=None, *args, **kwargs):
sourcestamps = sourcestampsInBuild or []
got_revisions = gotRevisionsInBuild or {}
yield super().setup_step(step, *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
m = self.master
m.db.checkForeignKeys = True
self.build.builder.botmaster = m.botmaster
self.build.conn = object()
m.config.buildbotURL = "baseurl/"
m.scheduler_manager = FakeSchedulerManager()
self.scheduler_a = a = FakeTriggerable(name='a')
self.scheduler_b = b = FakeTriggerable(name='b')
self.scheduler_c = c = FakeTriggerable(name='c')
m.scheduler_manager.namedServices = {"a": a, "b": b, "c": c}
a.brids = {77: 11}
b.brids = {78: 22}
c.brids = {79: 33, 80: 44}
def make_fake_br(brid, builderid):
return fakedb.BuildRequest(id=brid, buildsetid=BRID_TO_BSID(brid), builderid=builderid)
def make_fake_build(brid, builderid):
return fakedb.Build(
buildrequestid=brid,
id=BRID_TO_BID(brid),
number=BRID_TO_BUILD_NUMBER(brid),
masterid=9,
workerid=13,
builderid=builderid,
)
yield m.db.insert_test_data([
fakedb.Builder(id=77, name='A'),
fakedb.Builder(id=78, name='B'),
fakedb.Builder(id=79, name='C1'),
fakedb.Builder(id=80, name='C2'),
fakedb.Master(id=9),
fakedb.Buildset(id=2022),
fakedb.Buildset(id=2011),
fakedb.Buildset(id=2033),
fakedb.Worker(id=13, name="some:worker"),
make_fake_br(11, 77),
make_fake_br(22, 78),
fakedb.BuildRequest(id=33, buildsetid=2033, builderid=79),
fakedb.BuildRequest(id=44, buildsetid=2033, builderid=80),
make_fake_build(11, builderid=77),
make_fake_build(22, builderid=78),
make_fake_build(33, builderid=79),
# builderid is 79 on purpose, changed, from the one of the buildrequest
# to test the case of the virtual
make_fake_build(44, builderid=79),
])
def getAllSourceStamps():
return sourcestamps
self.build.getAllSourceStamps = getAllSourceStamps
def getAllGotRevisions():
return got_revisions
self.get_nth_step(0).getAllGotRevisions = getAllGotRevisions
self.exp_add_sourcestamp = None
self.exp_a_trigger = None
self.exp_b_trigger = None
self.exp_c_trigger = None
self.exp_added_urls = []
@defer.inlineCallbacks
def run_step(self, results_dict=None):
if results_dict is None:
results_dict = {}
if self.get_nth_step(0).waitForFinish:
for i in [11, 22, 33, 44]:
yield self.master.db.builds.finishBuild(
BRID_TO_BID(i), results_dict.get(i, SUCCESS)
)
d = super().run_step()
# the build doesn't finish until after a callLater, so this has the
# effect of checking whether the deferred has been fired already;
if self.get_nth_step(0).waitForFinish:
self.assertFalse(d.called)
else:
self.assertTrue(d.called)
yield d
self.assertEqual(self.scheduler_a.triggered_with, self.exp_a_trigger)
self.assertEqual(self.scheduler_b.triggered_with, self.exp_b_trigger)
# check the URLs
stepUrls = self.master.data.updates.stepUrls
if stepUrls:
got_added_urls = stepUrls[next(iter(stepUrls))]
else:
got_added_urls = []
self.assertEqual(sorted(got_added_urls), sorted(self.exp_added_urls))
if self.exp_add_sourcestamp:
self.assertEqual(self.addSourceStamp_kwargs, self.exp_add_sourcestamp)
# pause run_step's completion until after any other callLater's are done
d = defer.Deferred()
reactor.callLater(0, d.callback, None)
yield d
def expectTriggeredWith(self, a=None, b=None, c=None, d=None):
self.exp_a_trigger = a
if a is not None:
self.expectTriggeredLinks('a_br')
self.exp_b_trigger = b
if b is not None:
self.expectTriggeredLinks('b_br')
self.exp_c_trigger = c
if c is not None:
self.expectTriggeredLinks('c_br')
def expectAddedSourceStamp(self, **kwargs):
self.exp_add_sourcestamp = kwargs
def expectTriggeredLinks(self, *args):
if 'a_br' in args:
self.exp_added_urls.append(('a #11', 'baseurl/#/buildrequests/11'))
if 'b_br' in args:
self.exp_added_urls.append(('b #22', 'baseurl/#/buildrequests/22'))
if 'c_br' in args:
self.exp_added_urls.append(('c #33', 'baseurl/#/buildrequests/33'))
self.exp_added_urls.append(('c #44', 'baseurl/#/buildrequests/44'))
if 'a' in args:
self.exp_added_urls.append(('success: A #4011', 'baseurl/#/builders/77/builds/4011'))
if 'b' in args:
self.exp_added_urls.append(('success: B #4022', 'baseurl/#/builders/78/builds/4022'))
if 'afailed' in args:
self.exp_added_urls.append(('failure: A #4011', 'baseurl/#/builders/77/builds/4011'))
if 'c' in args:
self.exp_added_urls.append(('success: C1 #4033', 'baseurl/#/builders/79/builds/4033'))
self.exp_added_urls.append(('success: C1 #4044', 'baseurl/#/builders/79/builds/4044'))
# tests
def test_no_schedulerNames(self):
with self.assertRaises(config.ConfigErrors):
trigger.Trigger()
def test_unimportantSchedulerNames_not_in_schedulerNames(self):
with self.assertRaises(config.ConfigErrors):
trigger.Trigger(schedulerNames=['a'], unimportantSchedulerNames=['b'])
def test_unimportantSchedulerNames_not_in_schedulerNames_but_rendered(self):
# should not raise
trigger.Trigger(
schedulerNames=[properties.Interpolate('a')], unimportantSchedulerNames=['b']
)
def test_sourceStamp_and_updateSourceStamp(self):
with self.assertRaises(config.ConfigErrors):
trigger.Trigger(schedulerNames=['c'], sourceStamp={"x": 1}, updateSourceStamp=True)
def test_sourceStamps_and_updateSourceStamp(self):
with self.assertRaises(config.ConfigErrors):
trigger.Trigger(
schedulerNames=['c'], sourceStamps=[{"x": 1}, {"x": 2}], updateSourceStamp=True
)
def test_updateSourceStamp_and_alwaysUseLatest(self):
with self.assertRaises(config.ConfigErrors):
trigger.Trigger(schedulerNames=['c'], updateSourceStamp=True, alwaysUseLatest=True)
def test_sourceStamp_and_alwaysUseLatest(self):
with self.assertRaises(config.ConfigErrors):
trigger.Trigger(schedulerNames=['c'], sourceStamp={"x": 1}, alwaysUseLatest=True)
def test_sourceStamps_and_alwaysUseLatest(self):
with self.assertRaises(config.ConfigErrors):
trigger.Trigger(
schedulerNames=['c'], sourceStamps=[{"x": 1}, {"x": 2}], alwaysUseLatest=True
)
@defer.inlineCallbacks
def test_simple(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a'], sourceStamps={}))
self.expect_outcome(result=SUCCESS, state_string='triggered a')
self.expectTriggeredWith(a=(False, [], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_simple_failure(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a']))
self.scheduler_a.result = FAILURE
# not waitForFinish, so trigger step succeeds even though the build
# didn't fail
self.expect_outcome(result=SUCCESS, state_string='triggered a')
self.expectTriggeredWith(a=(False, [], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_simple_exception(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a']))
self.scheduler_a.exception = True
self.expect_outcome(result=SUCCESS, state_string='triggered a')
self.expectTriggeredWith(a=(False, [], {}))
yield self.run_step()
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
@defer.inlineCallbacks
def test_bogus_scheduler(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a', 'x']))
# bogus scheduler is an exception, not a failure (don't blame the patch)
self.expect_outcome(result=EXCEPTION)
self.expectTriggeredWith(a=None) # a is not triggered!
yield self.run_step()
self.flushLoggedErrors(ValueError)
@defer.inlineCallbacks
def test_updateSourceStamp(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a'], updateSourceStamp=True),
sourcestampsInBuild=[FakeSourceStamp(codebase='', repository='x', revision=11111)],
gotRevisionsInBuild={'': 23456},
)
self.expect_outcome(result=SUCCESS, state_string='triggered a')
self.expectTriggeredWith(
a=(False, [{'codebase': '', 'repository': 'x', 'revision': 23456}], {})
)
yield self.run_step()
@defer.inlineCallbacks
def test_updateSourceStamp_no_got_revision(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a'], updateSourceStamp=True),
sourcestampsInBuild=[FakeSourceStamp(codebase='', repository='x', revision=11111)],
)
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(
a=(
False,
# uses old revision
[{'codebase': '', 'repository': 'x', 'revision': 11111}],
{},
)
)
yield self.run_step()
@defer.inlineCallbacks
def test_not_updateSourceStamp(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a'], updateSourceStamp=False),
sourcestampsInBuild=[FakeSourceStamp(codebase='', repository='x', revision=11111)],
gotRevisionsInBuild={'': 23456},
)
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(
a=(False, [{'codebase': '', 'repository': 'x', 'revision': 11111}], {})
)
yield self.run_step()
@defer.inlineCallbacks
def test_updateSourceStamp_multiple_repositories(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a'], updateSourceStamp=True),
sourcestampsInBuild=[
FakeSourceStamp(codebase='cb1', revision='12345'),
FakeSourceStamp(codebase='cb2', revision='12345'),
],
gotRevisionsInBuild={'cb1': 23456, 'cb2': 34567},
)
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(
a=(
False,
[{'codebase': 'cb1', 'revision': 23456}, {'codebase': 'cb2', 'revision': 34567}],
{},
)
)
yield self.run_step()
@defer.inlineCallbacks
def test_updateSourceStamp_prop_false(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a'], updateSourceStamp=properties.Property('usess')),
sourcestampsInBuild=[FakeSourceStamp(codebase='', repository='x', revision=11111)],
gotRevisionsInBuild={'': 23456},
)
self.build.setProperty('usess', False, 'me')
self.expect_outcome(result=SUCCESS)
# didn't use got_revision
self.expectTriggeredWith(
a=(False, [{'codebase': '', 'repository': 'x', 'revision': 11111}], {})
)
yield self.run_step()
@defer.inlineCallbacks
def test_updateSourceStamp_prop_true(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a'], updateSourceStamp=properties.Property('usess')),
sourcestampsInBuild=[FakeSourceStamp(codebase='', repository='x', revision=11111)],
gotRevisionsInBuild={'': 23456},
)
self.build.setProperty('usess', True, 'me')
self.expect_outcome(result=SUCCESS)
# didn't use got_revision
self.expectTriggeredWith(
a=(False, [{'codebase': '', 'repository': 'x', 'revision': 23456}], {})
)
yield self.run_step()
@defer.inlineCallbacks
def test_alwaysUseLatest(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['b'], alwaysUseLatest=True),
sourcestampsInBuild=[FakeSourceStamp(codebase='', repository='x', revision=11111)],
)
self.expect_outcome(result=SUCCESS)
# Do not pass setid
self.expectTriggeredWith(b=(False, [], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_alwaysUseLatest_prop_false(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['b'], alwaysUseLatest=properties.Property('aul')),
sourcestampsInBuild=[FakeSourceStamp(codebase='', repository='x', revision=11111)],
)
self.build.setProperty('aul', False, 'me')
self.expect_outcome(result=SUCCESS)
# didn't use latest
self.expectTriggeredWith(
b=(False, [{'codebase': '', 'repository': 'x', 'revision': 11111}], {})
)
yield self.run_step()
@defer.inlineCallbacks
def test_alwaysUseLatest_prop_true(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['b'], alwaysUseLatest=properties.Property('aul')),
sourcestampsInBuild=[FakeSourceStamp(codebase='', repository='x', revision=11111)],
)
self.build.setProperty('aul', True, 'me')
self.expect_outcome(result=SUCCESS)
# didn't use latest
self.expectTriggeredWith(b=(False, [], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_sourceStamp(self):
ss = {"revision": 9876, "branch": 'dev'}
yield self.setup_step(trigger.Trigger(schedulerNames=['b'], sourceStamp=ss))
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(b=(False, [ss], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_set_of_sourceStamps(self):
ss1 = {"codebase": 'cb1', "repository": 'r1', "revision": 9876, "branch": 'dev'}
ss2 = {"codebase": 'cb2', "repository": 'r2', "revision": 5432, "branch": 'dev'}
yield self.setup_step(trigger.Trigger(schedulerNames=['b'], sourceStamps=[ss1, ss2]))
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(b=(False, [ss1, ss2], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_set_of_sourceStamps_override_build(self):
ss1 = {"codebase": 'cb1', "repository": 'r1', "revision": 9876, "branch": 'dev'}
ss2 = {"codebase": 'cb2', "repository": 'r2', "revision": 5432, "branch": 'dev'}
ss3 = FakeSourceStamp(codebase='cb3', repository='r3', revision=1234, branch='dev')
ss4 = FakeSourceStamp(codebase='cb4', repository='r4', revision=2345, branch='dev')
yield self.setup_step(
trigger.Trigger(schedulerNames=['b'], sourceStamps=[ss1, ss2]),
sourcestampsInBuild=[ss3, ss4],
)
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(b=(False, [ss1, ss2], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_sourceStamp_prop(self):
ss = {"revision": properties.Property('rev'), "branch": 'dev'}
yield self.setup_step(trigger.Trigger(schedulerNames=['b'], sourceStamp=ss))
self.build.setProperty('rev', 602, 'me')
expected_ss = {"revision": 602, "branch": 'dev'}
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(b=(False, [expected_ss], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_waitForFinish(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a', 'b'], waitForFinish=True))
self.expect_outcome(result=SUCCESS, state_string='triggered a, b')
self.expectTriggeredWith(a=(True, [], {}), b=(True, [], {}))
self.expectTriggeredLinks('a', 'b')
yield self.run_step()
@defer.inlineCallbacks
def test_waitForFinish_failure(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a'], waitForFinish=True))
self.scheduler_a.result = FAILURE
self.expect_outcome(result=FAILURE)
self.expectTriggeredWith(a=(True, [], {}))
self.expectTriggeredLinks('afailed')
yield self.run_step(results_dict={11: FAILURE})
@defer.inlineCallbacks
def test_waitForFinish_split_failure(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a', 'b'], waitForFinish=True))
self.scheduler_a.result = FAILURE
self.scheduler_b.result = SUCCESS
self.expect_outcome(result=FAILURE, state_string='triggered a, b')
self.expectTriggeredWith(a=(True, [], {}), b=(True, [], {}))
self.expectTriggeredLinks('afailed', 'b')
yield self.run_step(results_dict={11: FAILURE})
@defer.inlineCallbacks
def test_waitForFinish_exception(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a', 'b'], waitForFinish=True))
self.get_nth_step(0).addCompleteLog = Mock()
self.scheduler_b.exception = True
self.expect_outcome(result=EXCEPTION, state_string='triggered a, b')
self.expectTriggeredWith(a=(True, [], {}), b=(True, [], {}))
self.expectTriggeredLinks('a') # b doesn't return a brid
yield self.run_step()
self.assertEqual(len(self.get_nth_step(0).addCompleteLog.call_args_list), 1)
@defer.inlineCallbacks
def test_virtual_builder(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['c'], waitForFinish=True))
self.expect_outcome(result=SUCCESS, state_string='triggered c')
self.expectTriggeredWith(c=(True, [], {}))
self.expectTriggeredLinks('c')
yield self.run_step()
@defer.inlineCallbacks
def test_set_properties(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a'], set_properties={"x": 1, "y": 2})
)
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(a=(False, [], {"x": (1, 'Trigger'), "y": (2, 'Trigger')}))
yield self.run_step()
@defer.inlineCallbacks
def test_set_properties_prop(self):
yield self.setup_step(
trigger.Trigger(
schedulerNames=['a'], set_properties={"x": properties.Property('X'), "y": 2}
)
)
self.build.setProperty('X', 'xxx', 'here')
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(a=(False, [], {"x": ('xxx', 'Trigger'), "y": (2, 'Trigger')}))
yield self.run_step()
@defer.inlineCallbacks
def test_copy_properties(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a'], copy_properties=['a', 'b']))
self.build.setProperty('a', 'A', 'AA')
self.build.setProperty('b', 'B', 'BB')
self.build.setProperty('c', 'C', 'CC')
self.expect_outcome(result=SUCCESS)
self.expectTriggeredWith(a=(False, [], {"a": ('A', 'Trigger'), "b": ('B', 'Trigger')}))
yield self.run_step()
@defer.inlineCallbacks
def test_waitForFinish_interrupt(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a'], waitForFinish=True))
self.expect_outcome(result=CANCELLED, state_string='interrupted')
self.expectTriggeredWith(a=(True, [], {}))
d = self.run_step()
# interrupt before the callLater representing the Triggerable
# schedulers completes
self.get_nth_step(0).interrupt(failure.Failure(RuntimeError('oh noes')))
yield d
@defer.inlineCallbacks
def test_waitForFinish_interrupt_no_connection(self):
yield self.setup_step(trigger.Trigger(schedulerNames=['a'], waitForFinish=True))
self.expect_outcome(result=CANCELLED, state_string='interrupted')
self.expectTriggeredWith(a=(True, [], {}))
self.scheduler_a.never_finish = True
d = self.run_step()
# interrupt before the callLater representing the Triggerable
# schedulers completes
self.build.conn = None
self.get_nth_step(0).interrupt(failure.Failure(RuntimeError('oh noes')))
yield d
@defer.inlineCallbacks
def test_getSchedulersAndProperties_back_comp(self):
class DynamicTrigger(trigger.Trigger):
def getSchedulersAndProperties(self):
return [("a", {}, False), ("b", {}, True)]
yield self.setup_step(DynamicTrigger(schedulerNames=['a', 'b']))
self.scheduler_a.result = SUCCESS
self.scheduler_b.result = FAILURE
self.expect_outcome(result=SUCCESS, state_string='triggered a, b')
self.expectTriggeredWith(a=(False, [], {}), b=(False, [], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_unimportantSchedulerNames(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a', 'b'], unimportantSchedulerNames=['b'])
)
self.scheduler_a.result = SUCCESS
self.scheduler_b.result = FAILURE
self.expect_outcome(result=SUCCESS, state_string='triggered a, b')
self.expectTriggeredWith(a=(False, [], {}), b=(False, [], {}))
yield self.run_step()
@defer.inlineCallbacks
def test_unimportantSchedulerNames_with_more_brids_for_bsid(self):
yield self.setup_step(
trigger.Trigger(schedulerNames=['a', 'c'], unimportantSchedulerNames=['c'])
)
self.scheduler_a.result = SUCCESS
self.scheduler_c.result = FAILURE
self.expect_outcome(result=SUCCESS, state_string='triggered a, c')
self.expectTriggeredWith(a=(False, [], {}), c=(False, [], {}))
yield self.run_step()
| 25,767 | Python | .py | 553 | 37.690778 | 100 | 0.642399 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,498 | test_cmake.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_cmake.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.config import ConfigErrors
from buildbot.process.properties import Property
from buildbot.process.results import SUCCESS
from buildbot.steps.cmake import CMake
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
class TestCMake(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.setup_test_reactor(auto_tear_down=False)
yield self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def expect_and_run_command(self, *params):
command = [CMake.DEFAULT_CMAKE, *list(params)]
self.expect_commands(ExpectShell(command=command, workdir='wkdir').exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_definitions_type(self):
with self.assertRaises(ConfigErrors):
CMake(definitions='hello')
def test_options_type(self):
with self.assertRaises(ConfigErrors):
CMake(options='hello')
def test_plain(self):
self.setup_step(CMake())
self.expect_commands(ExpectShell(command=[CMake.DEFAULT_CMAKE], workdir='wkdir').exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_cmake(self):
cmake_bin = 'something/else/cmake'
self.setup_step(CMake(cmake=cmake_bin))
self.expect_commands(ExpectShell(command=[cmake_bin], workdir='wkdir').exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_cmake_interpolation(self):
prop = 'CMAKE'
value = 'Real_CMAKE'
self.setup_step(CMake(cmake=Property(prop)))
self.build.setProperty(prop, value, source='test')
self.expect_commands(ExpectShell(command=[value], workdir='wkdir').exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_definitions(self):
definition = {'a': 'b'}
self.setup_step(CMake(definitions=definition))
self.expect_and_run_command('-Da=b')
def test_environment(self):
command = [CMake.DEFAULT_CMAKE]
environment = {'a': 'b'}
self.setup_step(CMake(env=environment))
self.expect_commands(ExpectShell(command=command, workdir='wkdir', env={'a': 'b'}).exit(0))
self.expect_outcome(result=SUCCESS)
return self.run_step()
def test_definitions_interpolation(self):
definitions = {'a': Property('b')}
self.setup_step(CMake(definitions=definitions))
self.build.setProperty('b', 'real_b', source='test')
self.expect_and_run_command('-Da=real_b')
def test_definitions_renderable(self):
definitions = Property('b')
self.setup_step(CMake(definitions=definitions))
self.build.setProperty('b', {'a': 'real_b'}, source='test')
self.expect_and_run_command('-Da=real_b')
def test_generator(self):
generator = 'Ninja'
self.setup_step(CMake(generator=generator))
self.expect_and_run_command('-G', generator)
def test_generator_interpolation(self):
value = 'Our_GENERATOR'
self.setup_step(CMake(generator=Property('GENERATOR')))
self.build.setProperty('GENERATOR', value, source='test')
self.expect_and_run_command('-G', value)
def test_options(self):
options = ('A', 'B')
self.setup_step(CMake(options=options))
self.expect_and_run_command(*options)
def test_options_interpolation(self):
prop = 'option'
value = 'value'
self.setup_step(CMake(options=(Property(prop),)))
self.build.setProperty(prop, value, source='test')
self.expect_and_run_command(value)
def test_path(self):
path = 'some/path'
self.setup_step(CMake(path=path))
self.expect_and_run_command(path)
def test_path_interpolation(self):
prop = 'path'
value = 'some/path'
self.setup_step(CMake(path=Property(prop)))
self.build.setProperty(prop, value, source='test')
self.expect_and_run_command(value)
def test_options_path(self):
self.setup_step(CMake(path='some/path', options=('A', 'B')))
self.expect_and_run_command('A', 'B', 'some/path')
| 5,222 | Python | .py | 115 | 38.443478 | 99 | 0.686773 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
4,499 | test_subunit.py | buildbot_buildbot/master/buildbot/test/unit/steps/test_subunit.py | # This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import io
import re
import sys
from twisted.internet import defer
from twisted.trial import unittest
from buildbot.process.results import FAILURE
from buildbot.process.results import SUCCESS
from buildbot.steps import subunit
from buildbot.test.reactor import TestReactorMixin
from buildbot.test.steps import ExpectShell
from buildbot.test.steps import TestBuildStepMixin
try:
from subunit import TestProtocolClient
except ImportError:
TestProtocolClient = None
class FakeTest:
def __init__(self, id):
self._id = id
def id(self):
return self._id
def create_error(name):
try:
int('_' + name)
return None
except ValueError:
# We don't want traceback lines with real paths in the logs
exctype, value, _ = sys.exc_info()
return (exctype, value, None)
class TestSubUnit(TestBuildStepMixin, TestReactorMixin, unittest.TestCase):
def setUp(self):
if TestProtocolClient is None:
raise unittest.SkipTest("Need to install python-subunit to test subunit step")
self.setup_test_reactor(auto_tear_down=False)
return self.setup_test_build_step()
@defer.inlineCallbacks
def tearDown(self):
yield self.tear_down_test_build_step()
yield self.tear_down_test_reactor()
def test_empty(self):
self.setup_step(subunit.SubunitShellCommand(command='test'))
self.expect_commands(ExpectShell(workdir='wkdir', command="test").exit(0))
self.expect_outcome(result=SUCCESS, state_string="shell no tests run")
return self.run_step()
def test_empty_error(self):
self.setup_step(subunit.SubunitShellCommand(command='test', failureOnNoTests=True))
self.expect_commands(ExpectShell(workdir='wkdir', command="test").exit(0))
self.expect_outcome(result=FAILURE, state_string="shell no tests run (failure)")
return self.run_step()
def test_success(self):
stream = io.BytesIO()
client = TestProtocolClient(stream)
test = FakeTest(id='test1')
client.startTest(test)
client.stopTest(test)
self.setup_step(subunit.SubunitShellCommand(command='test'))
self.expect_commands(
ExpectShell(workdir='wkdir', command="test").stdout(stream.getvalue()).exit(0)
)
self.expect_outcome(result=SUCCESS, state_string="shell 1 test passed")
return self.run_step()
def test_error(self):
stream = io.BytesIO()
client = TestProtocolClient(stream)
test = FakeTest(id='test1')
client.startTest(test)
client.addError(test, create_error('error1'))
client.stopTest(test)
self.setup_step(subunit.SubunitShellCommand(command='test'))
self.expect_commands(
ExpectShell(workdir='wkdir', command="test").stdout(stream.getvalue()).exit(0)
)
self.expect_outcome(result=FAILURE, state_string="shell Total 1 test(s) 1 error (failure)")
self.expect_log_file(
'problems',
re.compile(
r"""test1
testtools.testresult.real._StringException:.*ValueError: invalid literal for int\(\) with base 10: '_error1'
.*""",
re.MULTILINE | re.DOTALL,
),
)
return self.run_step()
def test_multiple_errors(self):
stream = io.BytesIO()
client = TestProtocolClient(stream)
test1 = FakeTest(id='test1')
test2 = FakeTest(id='test2')
client.startTest(test1)
client.addError(test1, create_error('error1'))
client.stopTest(test1)
client.startTest(test2)
client.addError(test2, create_error('error2'))
client.stopTest(test2)
self.setup_step(subunit.SubunitShellCommand(command='test'))
self.expect_commands(
ExpectShell(workdir='wkdir', command="test").stdout(stream.getvalue()).exit(0)
)
self.expect_outcome(result=FAILURE, state_string="shell Total 2 test(s) 2 errors (failure)")
self.expect_log_file(
'problems',
re.compile(
r"""test1
testtools.testresult.real._StringException:.*ValueError: invalid literal for int\(\) with base 10: '_error1'
test2
testtools.testresult.real._StringException:.*ValueError: invalid literal for int\(\) with base 10: '_error2'
.*""",
re.MULTILINE | re.DOTALL,
),
)
return self.run_step()
def test_warnings(self):
stream = io.BytesIO()
client = TestProtocolClient(stream)
test1 = FakeTest(id='test1')
test2 = FakeTest(id='test2')
client.startTest(test1)
client.stopTest(test1)
client.addError(test2, create_error('error2'))
client.stopTest(test2)
self.setup_step(subunit.SubunitShellCommand(command='test'))
self.expect_commands(
ExpectShell(workdir='wkdir', command="test").stdout(stream.getvalue()).exit(0)
)
self.expect_outcome(
result=SUCCESS, # N.B. not WARNINGS
state_string="shell 1 test passed",
)
# note that the warnings list is ignored..
self.expect_log_file(
'warnings',
re.compile(
r"""error: test2 \[.*
ValueError: invalid literal for int\(\) with base 10: '_error2'
\]
""",
re.MULTILINE | re.DOTALL,
),
)
return self.run_step()
| 6,174 | Python | .py | 153 | 32.869281 | 108 | 0.664442 | buildbot/buildbot | 5,232 | 1,616 | 728 | GPL-2.0 | 9/5/2024, 5:09:21 PM (Europe/Amsterdam) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.