Esempio n. 1
0
    def test_remote_ssh_wol_action_no_keys(self, write_local_file_mock,
                                           temp_dir_mock):
        self.expect_commands(
            ExpectMaster([
                'ssh', '-o', 'BatchMode=yes', 'remote_host', 'wakeonlan',
                '00:11:22:33:44:55'
            ]).exit(0),
            ExpectMaster([
                'ssh', '-o', 'BatchMode=yes', 'remote_host', 'wolbin',
                '00:11:22:33:44:55'
            ]).exit(0),
        )

        manager = FakeManager(self.reactor)
        action = RemoteSshWOLAction('remote_host', '00:11:22:33:44:55')
        self.assertTrue((yield action.perform(manager)))

        action = RemoteSshWOLAction('remote_host',
                                    '00:11:22:33:44:55',
                                    wolBin='wolbin')
        self.assertTrue((yield action.perform(manager)))
        self.assert_all_commands_ran()

        self.assertEqual(temp_dir_mock.dirs, [])
        write_local_file_mock.assert_not_called()
Esempio n. 2
0
    def test_poll_force_push(self):
        #  There's a previous revision, but not linked with new rev
        self.expect_commands(
            ExpectMaster(
                ['hg', 'pull', '-b', 'default',
                 'ssh://example.com/foo/baz']).workdir('/some/dir'),
            ExpectMaster([
                'hg', 'heads', 'default', '--template={rev}' + os.linesep
            ]).workdir('/some/dir').stdout(b'5' + LINESEP_BYTES),
            ExpectMaster([
                'hg', 'log', '-r', '4::5', '--template={rev}:{node}\\n'
            ]).workdir('/some/dir').stdout(b""),
            ExpectMaster([
                'hg', 'log', '-r', '5', '--template={rev}:{node}\\n'
            ]).workdir('/some/dir').stdout(LINESEP_BYTES.join([b'5:784bd'])),
            ExpectMaster([
                'hg', 'log', '-r', '784bd', '--template={date|hgdate}' +
                os.linesep + '{author}' + os.linesep + "{files % '{file}" +
                os.pathsep + "'}" + os.linesep + '{desc|strip}'
            ]).workdir('/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')
Esempio n. 3
0
    def test_local_wake_action(self):
        self.expect_commands(
            ExpectMaster(['cmd', 'arg1', 'arg2']).exit(1),
            ExpectMaster(['cmd', 'arg1', 'arg2']).exit(0),
        )

        manager = FakeManager(self.reactor)
        action = LocalWakeAction(['cmd', 'arg1', 'arg2'])
        self.assertFalse((yield action.perform(manager)))
        self.assertTrue((yield action.perform(manager)))
        self.assert_all_commands_ran()
Esempio n. 4
0
    def test_local_wol_action(self):
        self.expect_commands(
            ExpectMaster(['wol', '00:11:22:33:44:55']).exit(1),
            ExpectMaster(['wakeonlan', '00:11:22:33:44:55']).exit(0),
        )

        manager = FakeManager(self.reactor)
        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.assert_all_commands_ran()
Esempio n. 5
0
    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.expect_commands(
            ExpectMaster(['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 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.assert_all_commands_ran()
Esempio n. 6
0
    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.expect_commands(
            ExpectMaster([
                'ssh', '-o', 'BatchMode=yes', '-i', ssh_key_path, '-o',
                'UserKnownHostsFile={0}'.format(ssh_known_hosts_path),
                'remote_host', 'remotebin', 'arg1'
            ]).exit(0), )

        manager = FakeManager(self.reactor, 'path-to-master')
        action = RemoteSshWakeAction('remote_host', ['remotebin', 'arg1'],
                                     sshKey='ssh_key',
                                     sshHostKey='ssh_host_key')
        self.assertTrue((yield action.perform(manager)))

        self.assert_all_commands_ran()

        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'),
        ])
Esempio n. 7
0
    def test_acquire_ticket_auth_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.expect_commands(
            ExpectMaster(['p4', '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']])
            pp.makeConnection(transport)
            self.assertEqual(b'pass\n', transport.msg)
            pp.outReceived(b'Enter password:\n')
            pp.errReceived(b"Password invalid.\n")
            so = error.ProcessDone(status=1)
            pp.processEnded(failure.Failure(so))

        self.patch(reactor, 'spawnProcess', spawnProcess)

        yield self.changesource.poll()
Esempio n. 8
0
 def method(testcase):
     testcase.expect_commands(ExpectMaster(["command"]))
     testcase.add_run_process_expect_env({'key': 'value'})
     res = yield runprocess.run_process(None, ["command"],
                                        env={'key': 'value'})
     self.assertEqual(res, (0, b'', b''))
     testcase.assert_all_commands_ran()
Esempio n. 9
0
 def method(testcase):
     testcase.expect_commands(
         ExpectMaster(["command"]).stderr(b"some test"))
     res = yield runprocess.run_process(None, ["command"],
                                        collect_stderr=False,
                                        stderr_is_error=True)
     self.assertEqual(res, (-1, b''))
     testcase.assert_all_commands_ran()
Esempio n. 10
0
 def method(testcase):
     testcase.expect_commands(
         ExpectMaster(["command"]).stdout(b'stdout').stderr(b'stderr'))
     res = yield runprocess.run_process(None, ["command"],
                                        collect_stdout=True,
                                        collect_stderr=False)
     self.assertEqual(res, (0, b'stdout'))
     testcase.assert_all_commands_ran()
Esempio n. 11
0
 def makeInfoExpect(self, password='******'):
     args = [
         'svn', 'info', '--xml', '--non-interactive', sample_base,
         '--username=dustin'
     ]
     if password is not None:
         args.append('--password=' + password)
     return ExpectMaster(args)
Esempio n. 12
0
    def test_prepare_base_image_full(self):
        self.expect_commands(ExpectMaster(["cp", "o", "p"]))

        bs = self.create_worker('bot', 'pass', hd_image='p', base_image='o')
        bs.cheap_copy = False
        yield bs._prepare_base_image()

        self.assert_all_commands_ran()
Esempio n. 13
0
    def test_prepare_base_image_fail(self):
        self.expect_commands(ExpectMaster(["cp", "o", "p"]).exit(1))

        bs = self.create_worker('bot', 'pass', hd_image='p', base_image='o')
        bs.cheap_copy = False
        with self.assertRaises(LatentWorkerFailedToSubstantiate):
            yield bs._prepare_base_image()

        self.assert_all_commands_ran()
Esempio n. 14
0
    def test_getFiles(self):
        s = self.newChangeSource('host', 'user', gerritport=2222)
        exp_argv = [
            'ssh', '-o', 'BatchMode=yes', 'user@host', '-p', '2222', 'gerrit',
            'query', '1000', '--format', 'JSON', '--files', '--patch-sets'
        ]

        self.expect_commands(
            ExpectMaster(exp_argv).stdout(self.query_files_success),
            ExpectMaster(exp_argv).stdout(self.query_files_failure))

        res = yield s.getFiles(1000, 13)
        self.assertEqual(set(res), {'/COMMIT_MSG', 'file1', 'file2'})

        res = yield s.getFiles(1000, 13)
        self.assertEqual(res, ['unknown'])

        self.assert_all_commands_ran()
Esempio n. 15
0
    def do_test_get_prefix(self, base, output, expected):
        s = self.attachSVNPoller(base)
        self.expect_commands(
            ExpectMaster(['svn', 'info', '--xml', '--non-interactive',
                          base]).stdout(output))
        prefix = yield s.get_prefix()

        self.assertEqual(prefix, expected)
        self.assert_all_commands_ran()
Esempio n. 16
0
    def test_poll_several_heads(self):
        # If there are several heads on the named branch, the poller mustn't
        # climb (good enough for now, ideally it should even go to the common
        # ancestor)
        self.expect_commands(
            ExpectMaster(
                ['hg', 'pull', '-b', 'default',
                 'ssh://example.com/foo/baz']).workdir('/some/dir'),
            ExpectMaster([
                'hg', 'heads', 'default', '--template={rev}' + os.linesep
            ]).workdir('/some/dir').stdout(b'5' + LINESEP_BYTES + b'6' +
                                           LINESEP_BYTES))

        yield self.poller._setCurrentRev(3)

        # do the poll: we must stay at rev 3
        yield self.poller.poll()
        yield self.check_current_rev(3)
Esempio n. 17
0
    def test_prepare_base_image_cheap(self):
        self.expect_commands(
            ExpectMaster(["qemu-img", "create", "-b", "o", "-f", "qcow2",
                          "p"]))

        bs = self.create_worker('bot', 'pass', hd_image='p', base_image='o')
        yield bs._prepare_base_image()

        self.assert_all_commands_ran()
Esempio n. 18
0
 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 ExpectMaster(args)
Esempio n. 19
0
    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.expect_commands(
            ExpectMaster([
                'hg', 'pull', '-B', 'one', '-B', 'two',
                'ssh://example.com/foo/baz'
            ]).workdir('/some/dir'),
            ExpectMaster([
                'hg', 'heads', 'one', '--template={rev}' + os.linesep
            ]).workdir('/some/dir').stdout(b'6' + LINESEP_BYTES),
            ExpectMaster(
                ['hg', 'log', '-r', '4::6',
                 '--template={rev}:{node}\\n']).workdir('/some/dir').stdout(
                     LINESEP_BYTES.join([
                         b'4:1aaa5',
                         b'6:784bd',
                     ])),
            ExpectMaster([
                'hg', 'log', '-r', '784bd', '--template={date|hgdate}' +
                os.linesep + '{author}' + os.linesep + "{files % '{file}" +
                os.pathsep + "'}" + os.linesep + '{desc|strip}'
            ]).workdir('/some/dir').stdout(
                LINESEP_BYTES.join([
                    b'1273258009.0 -7200', b'Joe Test <*****@*****.**>',
                    b'file1 file2', b'Comment', b''
                ])),
            ExpectMaster([
                'hg', 'heads', 'two', '--template={rev}' + os.linesep
            ]).workdir('/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['comments'], 'Comment')
Esempio n. 20
0
    def test_remote_ssh_wake_action_no_keys(self, write_local_file_mock,
                                            temp_dir_mock):
        self.expect_commands(
            ExpectMaster([
                'ssh', '-o', 'BatchMode=yes', 'remote_host', 'remotebin',
                'arg1'
            ]).exit(1),
            ExpectMaster([
                'ssh', '-o', 'BatchMode=yes', 'remote_host', 'remotebin',
                'arg1'
            ]).exit(0),
        )

        manager = FakeManager(self.reactor)
        action = RemoteSshWakeAction('remote_host', ['remotebin', 'arg1'])
        self.assertFalse((yield action.perform(manager)))
        self.assertTrue((yield action.perform(manager)))
        self.assert_all_commands_ran()

        self.assertEqual(temp_dir_mock.dirs, [])
        write_local_file_mock.assert_not_called()
Esempio n. 21
0
    def test_poll_initial(self):
        self.expect_commands(
            ExpectMaster([
                'hg', 'pull', '-b', 'one', '-b', 'two',
                'ssh://example.com/foo/baz'
            ]).workdir('/some/dir'),
            ExpectMaster([
                'hg', 'heads', 'one', '--template={rev}' + os.linesep
            ]).workdir('/some/dir').stdout(b"73591"),
            ExpectMaster([
                'hg', 'heads', 'two', '--template={rev}' + os.linesep
            ]).workdir('/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')
Esempio n. 22
0
    def test_poll_unicode_error2(self):
        self.attachChangeSource(
            P4Source(p4port=None,
                     p4user=None,
                     p4base='//depot/myproject/',
                     split_file=lambda x: x.split('/', 1),
                     encoding='ascii'))
        # Trying to decode a certain character with ascii codec should fail.
        self.expect_commands(
            ExpectMaster(['p4', 'changes', '-m', '1',
                          '//depot/myproject/...']).stdout(fourth_p4changes), )

        yield self.changesource._poll()
        self.assert_all_commands_ran()
Esempio n. 23
0
    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.add_run_process_expect_env(expected_env)
        self.expect_commands(
            ExpectMaster(['hg', 'init', '/some/dir']),
            ExpectMaster(
                ['hg', 'pull', '-b', 'default',
                 'ssh://example.com/foo/baz']).workdir('/some/dir'),
            ExpectMaster([
                'hg', 'heads', 'default', '--template={rev}' + os.linesep
            ]).workdir('/some/dir').stdout(b"73591"),
        )

        # 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)
Esempio n. 24
0
    def test_remote_ssh_suspend_action_no_keys(self, write_local_file_mock,
                                               temp_dir_mock):
        self.expect_commands(
            ExpectMaster([
                'ssh', '-o', 'BatchMode=yes', 'remote_host', 'systemctl',
                'suspend'
            ]).exit(0),
            ExpectMaster([
                'ssh', '-o', 'BatchMode=yes', 'remote_host', 'dosuspend',
                'arg1'
            ]).exit(0),
        )

        manager = FakeManager(self.reactor)
        action = RemoteSshSuspendAction('remote_host')
        self.assertTrue((yield action.perform(manager)))

        action = RemoteSshSuspendAction('remote_host',
                                        remoteCommand=['dosuspend', 'arg1'])
        self.assertTrue((yield action.perform(manager)))
        self.assert_all_commands_ran()

        self.assertEqual(temp_dir_mock.dirs, [])
        write_local_file_mock.assert_not_called()
Esempio n. 25
0
    def test_poll_failed_changes(self):
        self.attachChangeSource(
            P4Source(p4port=None,
                     p4user=None,
                     p4base='//depot/myproject/',
                     split_file=lambda x: x.split('/', 1)))
        self.expect_commands(
            ExpectMaster(['p4', 'changes', '-m', '1', '//depot/myproject/...'
                          ]).stdout(b'Perforce client error:\n...'))

        # call _poll, so we can catch the failure
        with self.assertRaises(P4PollerError):
            yield self.changesource._poll()

        self.assert_all_commands_ran()
Esempio n. 26
0
    def test_getFilesFromEvent(self):
        self.expect_commands(
            ExpectMaster([
                'ssh', '-o', 'BatchMode=yes', 'user@host', '-p', '29418',
                'gerrit', 'query', '4321', '--format', 'JSON', '--files',
                '--patch-sets'
            ]).stdout(self.query_files_success))

        s = self.newChangeSource('host',
                                 'user',
                                 get_files=True,
                                 handled_events=["change-merged"])

        yield s.lineReceived(json.dumps(self.change_merged_event))
        c = self.master.data.updates.changesAdded[0]
        self.assertEqual(set(c['files']), {'/COMMIT_MSG', 'file1', 'file2'})

        self.assert_all_commands_ran()
Esempio n. 27
0
    def test_poll_unicode_error(self):
        self.attachChangeSource(
            P4Source(p4port=None,
                     p4user=None,
                     p4base='//depot/myproject/',
                     split_file=lambda x: x.split('/', 1)))
        self.expect_commands(
            ExpectMaster(['p4', 'changes', '//depot/myproject/...@3,#head'
                          ]).stdout(second_p4changes), )
        # Add a character which cannot be decoded with utf-8
        undecodableText = p4change[2] + b"\x81"
        self.add_p4_describe_result(2, undecodableText)

        # tell poll() that it's already been called once
        self.changesource.last_change = 2

        # call _poll, so we can catch the failure
        with self.assertRaises(UnicodeError):
            yield self.changesource._poll()

        self.assert_all_commands_ran()
Esempio n. 28
0
    def test_poll_failed_describe(self):
        self.attachChangeSource(
            P4Source(p4port=None,
                     p4user=None,
                     p4base='//depot/myproject/',
                     split_file=lambda x: x.split('/', 1)))
        self.expect_commands(
            ExpectMaster(['p4', 'changes', '//depot/myproject/...@3,#head'
                          ]).stdout(second_p4changes), )
        self.add_p4_describe_result(2, p4change[2])
        self.add_p4_describe_result(3, b'Perforce client error:\n...')

        # tell poll() that it's already been called once
        self.changesource.last_change = 2

        # call _poll, so we can catch the failure
        with self.assertRaises(P4PollerError):
            yield self.changesource._poll()

        # check that 2 was processed OK
        self.assertEqual(self.changesource.last_change, 2)
        self.assert_all_commands_ran()
Esempio n. 29
0
 def method(testcase):
     testcase.expect_commands(ExpectMaster(["command"]))
     testcase.add_run_process_expect_env({'key': 'value'})
     d = runprocess.run_process(None, ["command"])
     return d
Esempio n. 30
0
 def test_method_chaining(self):
     expect = ExpectMaster('command')
     self.assertEqual(expect, expect.exit(0))
     self.assertEqual(expect, expect.stdout(b"output"))
     self.assertEqual(expect, expect.stderr(b"error"))