def verify_get_result(client, status, exit_code, stdout, stderr, custom_error,
                      started_at, finished_at):
    app = client.application

    with app.app_context():
        container_mock = ContainerFixture.new_with_status(
            container_id="fastlane-job-123",
            name="fastlane-job-123",
            status=status,
            exit_code=exit_code,
            started_at=started_at,
            finished_at=finished_at,
            custom_error=custom_error,
            stdout=stdout,
            stderr=stderr,
        )

        _, pool_mock, _ = PoolFixture.new_defaults(r"test[-].+",
                                                   max_running=1,
                                                   containers=[container_mock])

        executor = Executor(app, pool_mock)

        _, job, execution = JobExecutionFixture.new_defaults(
            container_id="fastlane-job-123")

        result = executor.get_result(job.task, job, execution)
        expect(result.status).to_equal(STATUS.get(status))
        expect(result.exit_code).to_equal(exit_code)

        if stdout is None:
            expect(result.log).to_be_empty()
        else:
            expect(result.log).to_equal(stdout)

        if stderr is not None and custom_error != "":
            expect(
                result.error).to_equal(f"{custom_error}\n\nstderr:\n{stderr}")
        else:
            if stderr is not None:
                expect(result.error).to_equal(stderr)
            else:
                expect(result.error).to_equal(custom_error)

        parsed_started_at = parse(started_at)
        expect(result.started_at).to_equal(parsed_started_at)

        if finished_at is not None:
            parsed_finished_at = parse(finished_at)
        else:
            parsed_finished_at = finished_at
        expect(result.finished_at).to_equal(parsed_finished_at)
def test_get_result3(client):
    app = client.application

    with app.app_context():
        container_mock = ContainerFixture.new_with_status(
            container_id="fastlane-job-123", name="fastlane-job-123")

        _, pool_mock, client_mock = PoolFixture.new_defaults(
            r"test[-].+", max_running=1, containers=[container_mock])
        client_mock.containers.get.side_effect = requests.exceptions.ConnectionError(
            "failed")

        executor = Executor(app, pool_mock)

        _, job, execution = JobExecutionFixture.new_defaults(
            container_id="fastlane-job-123")

        msg = "Connection to host host:1234 failed with error: failed"
        with expect.error_to_happen(HostUnavailableError, message=msg):
            executor.get_result(job.task, job, execution)
Пример #3
0
def test_stop1(client):
    """
    Tests stopping a job stops the container in docker
    """

    app = client.application

    with app.app_context():
        match, pool_mock, client_mock = PoolFixture.new_defaults(r"test[-].+",
                                                                 max_running=1)

        container_mock = ContainerFixture.new_with_status(
            name="fastlane-job-1234")
        client_mock.containers.get.return_value = container_mock

        task, job, execution = JobExecutionFixture.new_defaults(
            container_id="fastlane-job-1234")

        executor = Executor(app, pool_mock)

        executor.stop_job(task, job, execution)
        container_mock.stop.assert_called()
def test_stop1(client):
    """
    Tests stopping a job stops the container in docker
    """

    app = client.application

    with app.app_context():
        container_mock = ContainerFixture.new_with_status(
            name="fastlane-job-1234", container_id="fastlane-job-1234")
        _, pool_mock, _ = PoolFixture.new_defaults(r"test[-].+",
                                                   max_running=1,
                                                   containers=[container_mock])

        task, job, execution = JobExecutionFixture.new_defaults(
            container_id="fastlane-job-1234")

        executor = Executor(app, pool_mock)

        result = executor.stop_job(task, job, execution)
        container_mock.stop.assert_called()
        expect(result).to_be_true()