def test_poll_initial(self):
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work'),
gpo.Expect('git', 'fetch', self.REPOURL,
'+master:refs/buildbot/%s/master' % self.REPOURL_QUOTED)
.path('gitpoller-work'),
gpo.Expect('git', 'rev-parse',
'refs/buildbot/%s/master' % self.REPOURL_QUOTED)
.path('gitpoller-work')
.stdout('bf0b01df6d00ae8d1ffa0b2e2acbe642a6cd35d5\n'),
)
d = self.poller.poll()
@d.addCallback
def cb(_):
self.assertAllCommandsRan()
self.assertEqual(self.poller.lastRev, {
'master': 'bf0b01df6d00ae8d1ffa0b2e2acbe642a6cd35d5'
})
self.master.db.state.assertStateByClass(
name=self.REPOURL, class_name='GitPoller',
lastRev={
'master': 'bf0b01df6d00ae8d1ffa0b2e2acbe642a6cd35d5'
})
return d
def test_poll_initial(self):
self.repo_ready = False
# Test that environment variables get propagated to subprocesses
# (See #2116)
expected_env = {ENVIRON_2116_KEY: 'TRUE'}
self.addGetProcessOutputExpectEnv(expected_env)
self.expectCommands(
gpo.Expect('hg', 'init', '/some/dir'),
gpo.Expect('hg', 'pull', '-b', 'default',
'ssh://example.com/foo/baz').path('/some/dir'),
gpo.Expect('hg', 'heads', 'default', '--template={rev}' +
os.linesep).path('/some/dir').stdout("73591"),
gpo.Expect(
'hg',
'log',
'-b',
'default',
'-r',
'73591:73591', # only fetches that head
'--template={rev}:{node}\\n').path('/some/dir').stdout(
os.linesep.join(['73591:4423cdb'])),
gpo.Expect(
'hg', 'log', '-r', '4423cdb',
'--template={date|hgdate}' + os.linesep + '{author}' +
os.linesep + "{files % '{file}" + os.pathsep + "'}" +
os.linesep + '{desc|strip}').path('/some/dir').stdout(
os.linesep.join([
'1273258100.0 -7200', 'Bob Test <*****@*****.**>',
'file1 with spaces' + os.pathsep +
os.path.join('dir with spaces', 'file2') + os.pathsep,
'This is rev 73591', ''
])),
)
# do the poll
d = self.poller.poll()
# check the results
def check_changes(_):
self.assertEqual(len(self.master.data.updates.changesAdded), 1)
change = self.master.data.updates.changesAdded[0]
self.assertEqual(change['revision'], '4423cdb')
self.assertEqual(change['author'],
'Bob Test <*****@*****.**>')
if self.usetimestamps:
self.assertEqual(change['when_timestamp'], 1273258100)
else:
self.assertEqual(change['when_timestamp'], None)
self.assertEqual(change['files'], [
'file1 with spaces',
os.path.join('dir with spaces', 'file2')
])
self.assertEqual(change['src'], 'hg')
self.assertEqual(change['branch'], 'default')
self.assertEqual(change['comments'], 'This is rev 73591')
d.addCallback(check_changes)
d.addCallback(self.check_current_rev(73591))
return d
def test_poll_regular(self):
# normal operation. There's a previous revision, we get a new one.
self.expectCommands(
gpo.Expect('hg', 'pull', '-b', 'default',
'ssh://example.com/foo/baz').path('/some/dir'),
gpo.Expect('hg', 'heads', '-r', 'default', '--template={rev}' +
os.linesep).path('/some/dir').stdout(b'5' +
LINESEP_BYTES),
gpo.Expect('hg', 'log', '-r', '4::5',
'--template={rev}:{node}\\n').path('/some/dir').stdout(
LINESEP_BYTES.join([
b'4:1aaa5',
b'5:784bd',
])),
gpo.Expect(
'hg', 'log', '-r', '784bd',
'--template={date|hgdate}' + os.linesep + '{author}' +
os.linesep + "{files % '{file}" + os.pathsep + "'}" +
os.linesep + '{desc|strip}').path('/some/dir').stdout(
LINESEP_BYTES.join([
b'1273258009.0 -7200',
b'Joe Test <*****@*****.**>', b'file1 file2',
b'Comment for rev 5', b''
])),
)
yield self.poller._setCurrentRev(4)
yield self.poller.poll()
yield self.check_current_rev(5)
self.assertEqual(len(self.master.data.updates.changesAdded), 1)
change = self.master.data.updates.changesAdded[0]
self.assertEqual(change['revision'], '784bd')
self.assertEqual(change['comments'], 'Comment for rev 5')
def test_poll_multipleBranches_buildPushesWithNoCommits_default(self):
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work'),
gpo.Expect('git', 'fetch', self.REPOURL,
'+release:refs/buildbot/%s/release' % self.REPOURL_QUOTED)
.path('gitpoller-work'),
gpo.Expect('git', 'rev-parse',
'refs/buildbot/%s/release' % self.REPOURL_QUOTED)
.path('gitpoller-work')
.stdout('4423cdbcbb89c14e50dd5f4152415afd686c5241\n'),
gpo.Expect('git', 'log',
'--format=%H',
'4423cdbcbb89c14e50dd5f4152415afd686c5241',
'^4423cdbcbb89c14e50dd5f4152415afd686c5241',
'--')
.path('gitpoller-work')
.stdout(''),
)
# do the poll
self.poller.branches = ['release']
self.poller.lastRev = {
'master': '4423cdbcbb89c14e50dd5f4152415afd686c5241',
}
yield self.poller.poll()
self.assertAllCommandsRan()
self.assertEqual(self.poller.lastRev, {
'master': '4423cdbcbb89c14e50dd5f4152415afd686c5241',
'release': '4423cdbcbb89c14e50dd5f4152415afd686c5241'
})
self.assertEqual(len(self.master.data.updates.changesAdded), 0)
def test_poll_failLog(self):
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work'),
gpo.Expect('git', 'fetch', self.REPOURL,
'+master:refs/buildbot/%s/master' % self.REPOURL_QUOTED)
.path('gitpoller-work'),
gpo.Expect('git', 'rev-parse',
'refs/buildbot/%s/master' % self.REPOURL_QUOTED)
.path('gitpoller-work')
.stdout('4423cdbcbb89c14e50dd5f4152415afd686c5241\n'),
gpo.Expect('git', 'log',
'--format=%H',
'4423cdbcbb89c14e50dd5f4152415afd686c5241',
'^fa3ae8ed68e664d4db24798611b352e3c6509930',
'--')
.path('gitpoller-work')
.exit(1),
)
# do the poll
self.poller.lastRev = {
'master': 'fa3ae8ed68e664d4db24798611b352e3c6509930'
}
d = self.poller.poll()
@d.addCallback
def cb(_):
self.assertAllCommandsRan()
self.assertEqual(len(self.flushLoggedErrors()), 1)
self.assertEqual(self.poller.lastRev, {
'master': '4423cdbcbb89c14e50dd5f4152415afd686c5241'
})
def test_poll_multipleBranches_initial(self):
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work'),
gpo.Expect('git', 'fetch', self.REPOURL,
'+master:refs/buildbot/%s/master' % self.REPOURL_QUOTED,
'+release:refs/buildbot/%s/release' % self.REPOURL_QUOTED)
.path('gitpoller-work'),
gpo.Expect('git', 'rev-parse',
'refs/buildbot/%s/master' % self.REPOURL_QUOTED)
.path('gitpoller-work')
.stdout('4423cdbcbb89c14e50dd5f4152415afd686c5241\n'),
gpo.Expect('git', 'rev-parse',
'refs/buildbot/%s/release' % self.REPOURL_QUOTED)
.path('gitpoller-work')
.stdout('9118f4ab71963d23d02d4bdc54876ac8bf05acf2'),
)
# do the poll
self.poller.branches = ['master', 'release']
d = self.poller.poll()
@d.addCallback
def cb(_):
self.assertAllCommandsRan()
self.assertEqual(self.poller.lastRev, {
'master': '4423cdbcbb89c14e50dd5f4152415afd686c5241',
'release': '9118f4ab71963d23d02d4bdc54876ac8bf05acf2'
})
return d
def test_poll_noChanges(self):
# Test that environment variables get propagated to subprocesses
# (See #2116)
self.patch(os, 'environ', {'ENVVAR': 'TRUE'})
self.addGetProcessOutputExpectEnv({'ENVVAR': 'TRUE'})
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work'),
gpo.Expect('git', 'fetch', self.REPOURL,
'+master:refs/buildbot/%s/master' %
self.REPOURL_QUOTED).path('gitpoller-work').stdout(
'no interesting output'),
gpo.Expect('git', 'rev-parse', 'refs/buildbot/%s/master' %
self.REPOURL_QUOTED).path('gitpoller-work').stdout(
'4423cdbcbb89c14e50dd5f4152415afd686c5241\n'),
gpo.Expect('git', 'log', '--format=%H',
'4423cdbcbb89c14e50dd5f4152415afd686c5241',
'^4423cdbcbb89c14e50dd5f4152415afd686c5241',
'--').path('gitpoller-work').stdout(''),
)
self.poller.lastRev = {
'master': '4423cdbcbb89c14e50dd5f4152415afd686c5241'
}
d = self.poller.poll()
@d.addCallback
def cb(_):
self.assertAllCommandsRan()
self.assertEqual(
self.poller.lastRev,
{'master': '4423cdbcbb89c14e50dd5f4152415afd686c5241'})
return d
def test_poll_regular(self):
# normal operation. There's a previous revision, we get a new one.
self.expectCommands(
gpo.Expect('hg', 'pull', '-b', 'default',
'ssh://example.com/foo/baz').path('/some/dir'),
gpo.Expect('hg', 'heads', 'default', '--template={rev}' +
os.linesep).path('/some/dir').stdout('5' + os.linesep),
gpo.Expect('hg', 'log', '-b', 'default', '-r', '5:5',
'--template={rev}:{node}\\n').path('/some/dir').stdout(
'5:784bd' + os.linesep),
gpo.Expect(
'hg', 'log', '-r', '784bd',
'--template={date|hgdate}' + os.linesep + '{author}' +
os.linesep + "{files % '{file}" + os.pathsep + "'}" +
os.linesep + '{desc|strip}').path('/some/dir').stdout(
os.linesep.join([
'1273258009.0 -7200', 'Joe Test <*****@*****.**>',
'file1 file2', 'Comment for rev 5', ''
])),
)
yield self.poller._setCurrentRev(4)
d = self.poller.poll()
d.addCallback(self.check_current_rev(5))
def check_changes(_):
self.assertEquals(len(self.changes_added), 1)
change = self.changes_added[0]
self.assertEqual(change['revision'], '784bd')
self.assertEqual(change['comments'], 'Comment for rev 5')
d.addCallback(check_changes)
def _perform_git_output_test(self, methodToTest, args,
desiredGoodOutput, desiredGoodResult,
emptyRaisesException=True):
# make this call to self.patch here so that we raise a SkipTest if it
# is not supported
self.expectCommands(
gpo.Expect('git', *args)
.path('gitpoller-work'),
)
d = defer.succeed(None)
def call_empty(_):
# we should get an Exception with empty output from git
return methodToTest(self.dummyRevStr)
d.addCallback(call_empty)
def cb_empty(_):
if emptyRaisesException:
self.fail("getProcessOutput should have failed on empty output")
def eb_empty(f):
if not emptyRaisesException:
self.fail("getProcessOutput should NOT have failed on empty output")
d.addCallbacks(cb_empty, eb_empty)
d.addCallback(lambda _: self.assertAllCommandsRan())
# and the method shouldn't supress any exceptions
self.expectCommands(
gpo.Expect('git', *args)
.path('gitpoller-work')
.exit(1),
)
def call_exception(_):
return methodToTest(self.dummyRevStr)
d.addCallback(call_exception)
def cb_exception(_):
self.fail("getProcessOutput should have failed on stderr output")
def eb_exception(f):
pass
d.addCallbacks(cb_exception, eb_exception)
d.addCallback(lambda _: self.assertAllCommandsRan())
# finally we should get what's expected from good output
self.expectCommands(
gpo.Expect('git', *args)
.path('gitpoller-work')
.stdout(desiredGoodOutput)
)
def call_desired(_):
return methodToTest(self.dummyRevStr)
d.addCallback(call_desired)
def cb_desired(r):
self.assertEquals(r, desiredGoodResult)
d.addCallback(cb_desired)
d.addCallback(lambda _: self.assertAllCommandsRan())
def test_poll_failFetch(self):
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work'),
gpo.Expect('git', 'fetch', self.REPOURL,
'+master:refs/buildbot/%s/master' %
self.REPOURL_QUOTED).path('gitpoller-work').exit(1),
)
d = self.assertFailure(self.poller.poll(), EnvironmentError)
d.addCallback(lambda _: self.assertAllCommandsRan)
return d
def test_local_wake_action(self):
self.expectCommands(
gpo.Expect('cmd', 'arg1', 'arg2').exit(1),
gpo.Expect('cmd', 'arg1', 'arg2').exit(0),
)
manager = FakeManager()
action = LocalWakeAction(['cmd', 'arg1', 'arg2'])
self.assertFalse((yield action.perform(manager)))
self.assertTrue((yield action.perform(manager)))
self.assertAllCommandsRan()
def test_local_wol_action(self):
self.expectCommands(
gpo.Expect('wol', '00:11:22:33:44:55').exit(1),
gpo.Expect('wakeonlan', '00:11:22:33:44:55').exit(0),
)
manager = FakeManager()
action = LocalWOLAction('00:11:22:33:44:55', wolBin='wol')
self.assertFalse((yield action.perform(manager)))
action = LocalWOLAction('00:11:22:33:44:55')
self.assertTrue((yield action.perform(manager)))
self.assertAllCommandsRan()
def test_remote_ssh_wake_action_no_keys(self, write_local_file_mock,
temp_dir_mock):
self.expectCommands(
gpo.Expect('ssh', 'remote_host', 'remotebin', 'arg1').exit(1),
gpo.Expect('ssh', 'remote_host', 'remotebin', 'arg1').exit(0),
)
manager = FakeManager()
action = RemoteSshWakeAction('remote_host', ['remotebin', 'arg1'])
self.assertFalse((yield action.perform(manager)))
self.assertTrue((yield action.perform(manager)))
self.assertAllCommandsRan()
self.assertEqual(temp_dir_mock.dirs, [])
write_local_file_mock.assert_not_called()
def test_acquire_ticket_auth(self):
self.attachChangeSource(
P4Source(p4port=None,
p4user=None,
p4passwd='pass',
p4base='//depot/myproject/',
split_file=lambda x: x.split('/', 1),
use_tickets=True))
self.expectCommands(
gpo.Expect('p4', '-P', 'TICKET_ID_GOES_HERE', 'changes', '-m', '1',
'//depot/myproject/...').stdout(first_p4changes))
transport = FakeTransport()
# p4poller uses only those arguments at the moment
def spawnProcess(pp, cmd, argv, env):
self.assertEqual([cmd, argv], ['p4', [b'p4', b'login', b'-p']])
pp.makeConnection(transport)
self.assertEqual(b'pass\n', transport.msg)
pp.outReceived(
b'Enter password:\nSuccess: Password verified.\nTICKET_ID_GOES_HERE\n'
)
so = error.ProcessDone(None)
pp.processEnded(failure.Failure(so))
self.patch(reactor, 'spawnProcess', spawnProcess)
yield self.changesource.poll()
self.assertEqual(self.changesource._ticket_passwd,
'TICKET_ID_GOES_HERE')
def makeLogExpect(self, password='******'):
args = ['svn', 'log', '--xml', '--verbose', '--non-interactive',
'--username=dustin']
if password is not None:
args.append('--password='******'--limit=100', sample_base])
return gpo.Expect(*args)
def test_remote_ssh_wake_action_with_keys(self, write_local_file_mock,
temp_dir_mock):
temp_dir_path = os.path.join('path-to-master', 'ssh-@@@')
ssh_key_path = os.path.join(temp_dir_path, 'ssh-key')
ssh_known_hosts_path = os.path.join(temp_dir_path, 'ssh-known-hosts')
self.expectCommands(
gpo.Expect('ssh', '-o', 'BatchMode=yes', '-i', ssh_key_path, '-o',
'UserKnownHostsFile={0}'.format(ssh_known_hosts_path),
'remote_host', 'remotebin', 'arg1').exit(0), )
manager = FakeManager('path-to-master')
action = RemoteSshWakeAction('remote_host', ['remotebin', 'arg1'],
sshKey='ssh_key',
sshHostKey='ssh_host_key')
self.assertTrue((yield action.perform(manager)))
self.assertAllCommandsRan()
self.assertEqual(temp_dir_mock.dirs, [(temp_dir_path, 0o700)])
self.assertSequenceEqual(write_local_file_mock.call_args_list, [
mock.call(ssh_key_path, 'ssh_key', mode=0o400),
mock.call(ssh_known_hosts_path, '* ssh_host_key'),
])
def test_acquire_ticket_auth2_fail(self):
self.attachChangeSource(
P4Source(p4port=None,
p4user=None,
p4passwd='pass',
p4base='//depot/myproject/',
split_file=lambda x: x.split('/', 1),
use_tickets=True))
self.expectCommands(
gpo.Expect('p4', '-P', None, 'changes', '-m', '1',
'//depot/myproject/...').stdout(first_p4changes))
transport = FakeTransport()
# p4poller uses only those arguments at the moment
def spawnProcess(pp, cmd, argv, env):
self.assertEqual([cmd, argv], ['p4', [b'p4', b'login', b'-p']])
pp.makeConnection(transport)
self.assertEqual('pass\n', transport.msg)
pp.outReceived('Enter password:\n')
pp.errReceived(
"Password invalid.\n'auth-check' validation failed: Incorrect password!\n"
)
so = error.ProcessDone(status=1)
pp.processEnded(failure.Failure(so))
self.patch(reactor, 'spawnProcess', spawnProcess)
yield self.changesource.poll()
self.assertEqual(self.changesource._ticket_passwd, None)
def test_server_tz(self):
"""Verify that the server_tz parameter is handled correctly"""
self.attachChangeSource(
P4Source(p4port=None,
p4user=None,
p4base='//depot/myproject/',
split_file=get_simple_split,
server_tz="Europe/Berlin"))
self.expectCommands(
gpo.Expect(
'p4', 'changes',
'//depot/myproject/...@51,#head').stdout(third_p4changes), )
self.add_p4_describe_result(5, p4change[5])
self.changesource.last_change = 50
d = self.changesource.poll()
def check(res):
# when_timestamp is converted from 21:55:39 Berlin time to UTC
when_berlin = self.makeTime("2006/04/13 21:55:39")
when_berlin = when_berlin.replace(
tzinfo=dateutil.tz.gettz('Europe/Berlin'))
when = datetime2epoch(when_berlin)
self.assertEqual([
ch['when_timestamp']
for ch in self.master.data.updates.changesAdded
], [when, when])
self.assertAllCommandsRan()
d.addCallback(check)
return d
def test_poll_failed_describe(self):
self.attachChangeSource(
P4Source(p4port=None,
p4user=None,
p4base='//depot/myproject/',
split_file=lambda x: x.split('/', 1)))
self.expectCommands(
gpo.Expect(
'p4', 'changes',
'//depot/myproject/...@3,#head').stdout(second_p4changes), )
self.add_p4_describe_result(2, p4change[2])
self.add_p4_describe_result(3, 'Perforce client error:\n...')
self.changesource.last_change = 2 # tell poll() that it's already been called once
# call _poll, so we can catch the failure
d = self.changesource._poll()
self.assertFailure(d, P4PollerError)
@d.addCallback
def check(_):
# check that 2 was processed OK
self.assertEquals(self.changesource.last_change, 2)
self.assertAllCommandsRan()
return d
def makeInfoExpect(self, password='******'):
args = [
'svn', 'info', '--xml', '--non-interactive', sample_base,
'--username=dustin'
]
if password is not None:
args.append('--password=' + password)
return gpo.Expect(*args)
def do_test_get_prefix(self, base, output, expected):
s = self.attachSVNPoller(base)
self.expectCommands(
gpo.Expect('svn', 'info', '--xml', '--non-interactive', base).stdout(output))
prefix = yield s.get_prefix()
self.assertEqual(prefix, expected)
self.assertAllCommandsRan()
def test_poll_several_heads(self):
# If there are several heads on the named branch, the poller musn't
# climb (good enough for now, ideally it should even go to the common
# ancestor)
self.expectCommands(
gpo.Expect('hg', 'pull', '-b', 'default',
'ssh://example.com/foo/baz')
.path('/some/dir'),
gpo.Expect('hg', 'heads', 'default', '--template={rev}' + os.linesep)
.path('/some/dir').stdout('5' + os.linesep + '6' + os.linesep),
)
yield self.poller._setCurrentRev(3)
# do the poll: we must stay at rev 3
d = self.poller.poll()
d.addCallback(self.check_current_rev(3))
def test_poll_failRevParse(self):
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work'),
gpo.Expect('git', 'fetch', self.REPOURL,
'+master:refs/buildbot/%s/master' %
self.REPOURL_QUOTED).path('gitpoller-work'),
gpo.Expect('git', 'rev-parse', 'refs/buildbot/%s/master' %
self.REPOURL_QUOTED).path('gitpoller-work').exit(1),
)
d = self.poller.poll()
@d.addCallback
def cb(_):
self.assertAllCommandsRan()
self.assertEqual(len(self.flushLoggedErrors()), 1)
self.assertEqual(self.poller.lastRev, {})
def test_poll_failInit(self):
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work').exit(1), )
d = self.assertFailure(self.poller.poll(), EnvironmentError)
d.addCallback(lambda _: self.assertAllCommandsRan)
return d
def test_poll_split_file(self):
"""Make sure split file works on branch only changes"""
self.attachChangeSource(
P4Source(p4port=None, p4user=None,
p4base='//depot/myproject/',
split_file=get_simple_split))
self.expectCommands(
gpo.Expect(
'p4', 'changes', '//depot/myproject/...@51,#head').stdout(third_p4changes),
)
self.add_p4_describe_result(5, p4change[5])
self.changesource.last_change = 50
yield self.changesource.poll()
# when_timestamp is converted from a local time spec, so just
# replicate that here
when = self.makeTime("2006/04/13 21:55:39")
def changeKey(change):
""" Let's sort the array of changes by branch,
because in P4Source._poll(), changeAdded()
is called by iterating over a dictionary of
branches"""
return change['branch']
self.assertEqual(sorted(self.master.data.updates.changesAdded, key=changeKey),
sorted([{
'author': 'mpatel',
'branch': 'branch_c',
'category': None,
'codebase': None,
'comments': 'This is a multiline comment with tabs and spaces\n\nA list:\n Item 1\n\tItem 2',
'files': ['branch_c_file'],
'project': '',
'properties': {},
'repository': '',
'revision': '5',
'revlink': '',
'src': None,
'when_timestamp': datetime2epoch(when),
}, {
'author': 'mpatel',
'branch': 'branch_b',
'category': None,
'codebase': None,
'comments': 'This is a multiline comment with tabs and spaces\n\nA list:\n Item 1\n\tItem 2',
'files': ['branch_b_file'],
'project': '',
'properties': {},
'repository': '',
'revision': '5',
'revlink': '',
'src': None,
'when_timestamp': datetime2epoch(when),
}], key=changeKey))
self.assertEqual(self.changesource.last_change, 5)
self.assertAllCommandsRan()
def test_poll_regular(self):
# normal operation. There's a previous revision, we get a new one.
# Let's say there was an intervening commit on an untracked branch, to
# make it more interesting.
self.expectCommands(
gpo.Expect('hg', 'pull', '-b', 'one', '-b', 'two',
'ssh://example.com/foo/baz')
.path('/some/dir'),
gpo.Expect(
'hg', 'heads', 'one', '--template={rev}' + os.linesep)
.path('/some/dir').stdout(b'6' + LINESEP_BYTES),
gpo.Expect('hg', 'log', '-r', '4::6',
'--template={rev}:{node}\\n')
.path('/some/dir').stdout(LINESEP_BYTES.join([
b'4:1aaa5',
b'6:784bd',
])),
gpo.Expect('hg', 'log', '-r', '784bd',
'--template={date|hgdate}' + os.linesep +
'{author}' + os.linesep +
"{files % '{file}" +
os.pathsep + "'}" +
os.linesep + '{desc|strip}')
.path('/some/dir').stdout(LINESEP_BYTES.join([
b'1273258009.0 -7200',
b'Joe Test <*****@*****.**>',
b'file1 file2',
b'Comment',
b''])),
gpo.Expect(
'hg', 'heads', 'two', '--template={rev}' + os.linesep)
.path('/some/dir').stdout(b'3' + LINESEP_BYTES),
)
yield self.poller._setCurrentRev(3, 'two')
yield self.poller._setCurrentRev(4, 'one')
yield self.poller.poll()
yield self.check_current_rev(6, 'one')
self.assertEqual(len(self.master.data.updates.changesAdded), 1)
change = self.master.data.updates.changesAdded[0]
self.assertEqual(change['revision'], '784bd')
self.assertEqual(change['revlink'], 'http://example.com/foo/baz/rev/784bd')
self.assertEqual(change['comments'], 'Comment')
def do_test_get_prefix(self, base, output, expected):
s = self.attachSVNPoller(base)
self.expectCommands(gpo.Expect('svn', 'info', '--xml', '--non-interactive', base).stdout(output))
d = s.get_prefix()
def check(prefix):
self.failUnlessEqual(prefix, expected)
self.assertAllCommandsRan()
d.addCallback(check)
return d
def test_poll_GitError_log(self):
self.setUpLogging()
self.expectCommands(
gpo.Expect('git', 'init', '--bare', 'gitpoller-work').exit(128), )
d = self.poller.poll()
d.addCallback(lambda _: self.assertAllCommandsRan())
self.assertLogged("command.*on repourl.*failed.*exit code 128.*")
return d
def test_remote_ssh_suspend_action_no_keys(self, write_local_file_mock,
temp_dir_mock):
self.expectCommands(
gpo.Expect('ssh', 'remote_host', 'systemctl', 'suspend').exit(0),
gpo.Expect('ssh', 'remote_host', 'dosuspend', 'arg1').exit(0),
)
manager = FakeManager()
action = RemoteSshSuspendAction('remote_host')
self.assertTrue((yield action.perform(manager)))
action = RemoteSshSuspendAction('remote_host',
remoteCommand=['dosuspend', 'arg1'])
self.assertTrue((yield action.perform(manager)))
self.assertAllCommandsRan()
self.assertEqual(temp_dir_mock.dirs, [])
write_local_file_mock.assert_not_called()
def test_poll_initial(self):
self.expectCommands(
gpo.Expect('hg', 'pull', '-b', 'one', '-b', 'two',
'ssh://example.com/foo/baz').path('/some/dir'),
gpo.Expect('hg', 'heads', '-r', 'one', '--template={rev}' +
os.linesep).path('/some/dir').stdout(b"73591"),
gpo.Expect('hg', 'heads', '-r', 'two', '--template={rev}' +
os.linesep).path('/some/dir').stdout(b"22341"),
)
# do the poll
yield self.poller.poll()
# check the results
self.assertEqual(len(self.master.data.updates.changesAdded), 0)
yield self.check_current_rev(73591, 'one')
yield self.check_current_rev(22341, 'two')
