def test_status_pending_pipeline_build_message(
        mock_get_actual_deployments, mock_get_deploy_info,
        mock_figure_out_service_name, mock_load_system_paasta_config,
        mock_list_services, mock_get_instance_configs_for_service, capfd,
        system_paasta_config,
):
    # If deployments.json is missing SERVICE, output the appropriate message
    service = 'fake_service'
    mock_figure_out_service_name.return_value = service
    mock_list_services.return_value = [service]
    pipeline = [{'instancename': 'cluster.instance'}]
    mock_get_deploy_info.return_value = {'pipeline': pipeline}
    mock_load_system_paasta_config.return_value = system_paasta_config
    mock_instance_config = make_fake_instance_conf('cluster', service, 'instancename')
    mock_get_instance_configs_for_service.return_value = [mock_instance_config]

    actual_deployments = {}
    mock_get_actual_deployments.return_value = actual_deployments
    expected_output = missing_deployments_message(service)

    args = MagicMock()
    args.service = service
    args.deploy_group = None
    args.clusters = None
    args.instances = None
    args.owner = None
    args.soa_dir = utils.DEFAULT_SOA_DIR
    args.registration = None

    paasta_status(args)
    output, _ = capfd.readouterr()
    assert expected_output in output
Exemple #2
0
def test_status_arg_service_not_found(
    mock_guess_service_name,
    mock_validate_service_name,
    mock_load_system_paasta_config,
    mock_list_clusters,
    capfd,
    system_paasta_config,
):
    # paasta_status with no args and non-service directory results in error
    mock_guess_service_name.return_value = 'not_a_service'
    error = NoSuchService('fake_service')
    mock_validate_service_name.side_effect = error
    mock_list_clusters.return_value = ['cluster1']
    mock_load_system_paasta_config.return_value = system_paasta_config
    expected_output = str(error) + "\n"

    args = MagicMock()
    args.service = None
    args.owner = None
    args.clusters = None
    args.instances = None
    args.deploy_group = None
    args.registration = None

    # Fail if exit(1) does not get called
    with raises(SystemExit) as sys_exit:
        paasta_status(args)

    output, _ = capfd.readouterr()
    assert sys_exit.value.code == 1
    assert output == expected_output
Exemple #3
0
    def test_list_vm(self, suds_cli):
        client = MagicMock()
        service = MagicMock()
        vmrc_res = MagicMock()
        vmrc_res.name = "Image"
        vmrc_res.hypervisor = "qemu"
        vmrc_res.userPassword = "******"
        vmrc_res.userLogin = "******"
        vmrc_res.os = MagicMock()
        vmrc_res.os.name = "linux"
        vmrc_res.os.flavour = "ubuntu"
        vmrc_res.os.version = "14.04"
        vmrc_res.location = "one://server.com/1"
        service.list.return_value = [vmrc_res]
        client.service = service
        suds_cli.return_value = client

        vmrc = VMRC("http://host:8080/vmrc/vmrc", "user", "pass")

        res_radl = vmrc.list_vm()
        self.assertEqual(len(res_radl), 1)
        self.assertEqual(res_radl[0].getValue("disk.0.image.url"),
                         "one://server.com/1")
        self.assertEqual(
            res_radl[0].getValue("disk.0.os.credentials.password"), "pass")
        self.assertEqual(
            res_radl[0].getValue("disk.0.os.credentials.username"), "user")
def test_status_calls_sergeants(
    mock_stdout,
    mock_report_status,
    mock_get_planned_deployments,
    mock_get_actual_deployments,
    mock_get_deploy_info,
    mock_figure_out_service_name,
):
    service = 'fake_service'
    mock_figure_out_service_name.return_value = service

    pipeline = [{'instancename': 'cluster.instance'}]
    deploy_info = {'pipeline': pipeline}
    planned_deployments = [
        'cluster1.instance1', 'cluster1.instance2', 'cluster2.instance1']
    mock_get_deploy_info.return_value = deploy_info
    mock_get_planned_deployments.return_value = planned_deployments

    actual_deployments = {
        'fake_service:paasta-cluster.instance': 'this_is_a_sha'
    }
    mock_get_actual_deployments.return_value = actual_deployments

    args = MagicMock()
    args.service = service
    args.clusters = None
    args.verbose = False
    paasta_status(args)

    mock_figure_out_service_name.assert_called_once_with(args)
    mock_get_actual_deployments.assert_called_once_with(service)
    mock_get_deploy_info.assert_called_once_with(service)
    mock_report_status.assert_called_once_with(
        service, planned_deployments, actual_deployments, None, False)
def test_generate_pipeline_success_with_no_opts(mock_generate_pipeline, mock_validate_service_name):
    # paasta generate succeeds when service name provided as arg
    mock_validate_service_name.return_value = None
    args = MagicMock()
    args.service = "fake_service"
    assert paasta_generate_pipeline(args) is None
    mock_generate_pipeline.assert_called_once_with(service="fake_service", soa_dir=ANY)
def test_rerun_validations(test_case):
    with contextlib.nested(
        patch('sys.stdout', new_callable=StringIO),
        patch('paasta_tools.cli.cmds.rerun.figure_out_service_name', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.list_clusters', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.get_actual_deployments', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.get_planned_deployments', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.execute_chronos_rerun_on_remote_master', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.chronos_tools.load_chronos_job_config', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.chronos_tools.uses_time_variables', autospec=True),
        patch('paasta_tools.cli.cmds.rerun._get_default_execution_date', autospec=True),
    ) as (
        mock_stdout,
        mock_figure_out_service_name,
        mock_list_clusters,
        mock_get_actual_deployments,
        mock_get_planned_deployments,
        mock_execute_rerun_remote,
        mock_load_chronos_job_config,
        mock_uses_time_variables,
        mock_get_default_execution_date,
    ):

        (rerun_args,
         mock_figure_out_service_name.return_value,
         mock_list_clusters.return_value,
         mock_get_actual_deployments.return_value,
         mock_get_planned_deployments.return_value,
         mock_uses_time_variables.return_value,
         expected_output) = test_case

        mock_load_chronos_job_config.return_value = {}
        default_date = datetime.datetime(2002, 2, 2, 2, 2, 2, 2)
        mock_get_default_execution_date.return_value = default_date
        mock_execute_rerun_remote.return_value = (0, '')

        args = MagicMock()
        args.service = rerun_args[0]
        args.instance = rerun_args[1]
        args.clusters = rerun_args[2]
        if rerun_args[3]:
            args.execution_date = datetime.datetime.strptime(rerun_args[3], EXECUTION_DATE_FORMAT)
        else:
            args.execution_date = None
        args.verbose = 0

        paasta_rerun(args)

        # No --execution_date argument, but that's ok: the job doesn't use time vars interpolation.
        # Check if the backend rerun command was called with the default date.
        if args.execution_date is None and not mock_uses_time_variables.return_value:
            assert mock_execute_rerun_remote.call_args[1]['execution_date'] \
                == default_date.strftime(EXECUTION_DATE_FORMAT)

        # The job does use time vars interpolation. Make sure the User supplied date was used.
        if args.execution_date is not None and mock_uses_time_variables.return_value:
            assert mock_execute_rerun_remote.call_args[1]['execution_date'] == _user_supplied_execution_date

        output = mock_stdout.getvalue()
        assert expected_output in output
def test_status_calls_sergeants(
    mock_stdout,
    mock_report_status,
    mock_get_planned_deployments,
    mock_get_actual_deployments,
    mock_figure_out_service_name,
):
    service = "fake_service"
    mock_figure_out_service_name.return_value = service

    planned_deployments = ["cluster1.instance1", "cluster1.instance2", "cluster2.instance1"]
    mock_get_planned_deployments.return_value = planned_deployments

    actual_deployments = {"fake_service:paasta-cluster.instance": "this_is_a_sha"}
    mock_get_actual_deployments.return_value = actual_deployments

    args = MagicMock()
    args.service = service
    args.clusters = None
    args.instances = None
    args.verbose = False
    paasta_status(args)

    mock_figure_out_service_name.assert_called_once_with(args)
    mock_get_actual_deployments.assert_called_once_with(service)
    mock_report_status.assert_called_once_with(
        service=service,
        deploy_pipeline=planned_deployments,
        actual_deployments=actual_deployments,
        cluster_whitelist=[],
        instance_whitelist=[],
        verbose=0,
    )
Exemple #8
0
def test_status_pending_pipeline_build_message(
    mock_get_actual_deployments,
    mock_get_deploy_info,
    mock_figure_out_service_name,
    mock_load_system_paasta_config,
    capfd,
):
    # If deployments.json is missing SERVICE, output the appropriate message
    service = 'fake_service'
    mock_figure_out_service_name.return_value = service
    pipeline = [{'instancename': 'cluster.instance'}]
    mock_get_deploy_info.return_value = {'pipeline': pipeline}
    fake_system_paasta_config = utils.SystemPaastaConfig({}, '/fake/config')
    mock_load_system_paasta_config.return_value = fake_system_paasta_config

    actual_deployments = {}
    mock_get_actual_deployments.return_value = actual_deployments
    expected_output = missing_deployments_message(service)

    args = MagicMock()
    args.service = service
    args.deploy_group = None

    paasta_status(args)
    output, _ = capfd.readouterr()
    assert expected_output in output
Exemple #9
0
def test_status_calls_sergeants(
    mock_report_status,
    mock_get_planned_deployments,
    mock_get_actual_deployments,
    mock_figure_out_service_name,
    mock_load_system_paasta_config,
    mock_list_services,
    mock_get_instance_configs_for_service,
    system_paasta_config,
):
    service = 'fake_service'
    cluster = 'fake_cluster'
    mock_figure_out_service_name.return_value = service
    mock_list_services.return_value = [service]

    mock_instance_config = make_fake_instance_conf(cluster, service, 'fi')
    mock_instance_config.get_service.return_value = service
    mock_instance_config.get_cluster.return_value = cluster
    mock_get_instance_configs_for_service.return_value = [mock_instance_config]

    planned_deployments = [
        'cluster1.instance1',
        'cluster1.instance2',
        'cluster2.instance1',
    ]
    mock_get_planned_deployments.return_value = planned_deployments

    actual_deployments = {
        'fake_service:paasta-cluster.instance': 'this_is_a_sha',
    }
    mock_get_actual_deployments.return_value = actual_deployments
    mock_load_system_paasta_config.return_value = system_paasta_config
    mock_report_status.return_value = 1776, ['dummy', 'output']

    args = MagicMock()
    args.service = service
    args.clusters = None
    args.instances = None
    args.verbose = False
    args.owner = None
    args.deploy_group = None
    args.soa_dir = '/fake/soa/dir'
    args.registration = None
    return_value = paasta_status(args)

    assert return_value == 1776

    mock_get_actual_deployments.assert_called_once_with(
        service, '/fake/soa/dir')
    mock_report_status.assert_called_once_with(
        service=service,
        deploy_pipeline=planned_deployments,
        actual_deployments=actual_deployments,
        cluster=cluster,
        instance_whitelist={'fi': mock_instance_config.__class__},
        system_paasta_config=system_paasta_config,
        verbose=False,
        use_api_endpoint=False,
    )
def test_generate_pipeline_success_with_opts(mock_generate_pipeline,
                                             mock_validate_service_name):
    # paasta generate succeeds when service name provided as arg
    mock_validate_service_name.return_value = None
    args = MagicMock()
    args.service = 'fake_service'
    assert paasta_generate_pipeline(args) is None
    mock_generate_pipeline.assert_called_once_with(service='fake_service')
def test_paasta_generate_pipeline_success_guesses_service_name(
    mock_generate_pipeline, mock_guess_service_name, mock_validate_service_name
):
    # paasta generate succeeds when service name must be guessed
    mock_guess_service_name.return_value = "fake_service"
    mock_validate_service_name.return_value = None
    args = MagicMock()
    args.service = None
    assert paasta_generate_pipeline(args) is None
    mock_generate_pipeline.assert_called_once_with(service="fake_service", soa_dir=ANY)
def test_paasta_generate_pipeline_success_no_opts(mock_generate_pipeline,
                                                  mock_guess_service_name,
                                                  mock_validate_service_name):
    # paasta generate succeeds when service name must be guessed
    mock_guess_service_name.return_value = 'fake_service'
    mock_validate_service_name.return_value = None
    args = MagicMock()
    args.service = None
    assert paasta_generate_pipeline(args) is None
    mock_generate_pipeline.assert_called_once_with(service='fake_service')
Exemple #13
0
def test_itest_works_when_service_name_starts_with_services_dash(
    mock_docker_image, mock_exit, mock_log, mock_build_docker_tag, mock_run, mock_validate_service_name
):
    mock_docker_image.return_value = True
    mock_build_docker_tag.return_value = "unused_docker_tag"
    mock_run.return_value = (0, "Yeeehaaa")
    args = MagicMock()
    args.service = "services-fake_service"
    args.commit = "unused"
    assert paasta_itest(args) is None
    mock_build_docker_tag.assert_called_once_with("fake_service", "unused")
def test_push_to_registry_works_when_service_name_starts_with_services_dash(
    mock_build_command,
    mock_log,
    mock_run,
    mock_validate_service_name,
):
    mock_run.return_value = (0, 'Success')
    args = MagicMock()
    args.service = 'fake_service'
    args.commit = 'unused'
    assert paasta_push_to_registry(args) == 0
    mock_build_command.assert_called_once_with('fake_service', 'unused')
Exemple #15
0
def test_push_to_registry_works_when_service_name_starts_with_services_dash(
    mock_build_command,
    mock_log,
    mock_run,
    mock_validate_service_name,
):
    mock_run.return_value = (0, 'Success')
    args = MagicMock()
    args.service = 'fake_service'
    args.commit = 'unused'
    assert paasta_push_to_registry(args) == 0
    mock_build_command.assert_called_once_with('fake_service', 'unused')
def test_paasta_generate_pipeline_success_no_opts(
        mock_generate_pipeline,
        mock_guess_service_name,
        mock_validate_service_name):
    # paasta generate succeeds when service name must be guessed
    mock_guess_service_name.return_value = 'fake_service'
    mock_validate_service_name.return_value = None
    args = MagicMock()
    args.service = None
    args.soa_dir = '/fake/soa/dir'
    assert paasta_generate_pipeline(args) is None
    mock_generate_pipeline.assert_called_once_with(service='fake_service', soa_dir='/fake/soa/dir')
def test_paasta_generate_pipeline_service_not_found(mock_stdout, mock_guess_service_name, mock_validate_service_name):
    # paasta generate cannot guess service name and none is provided

    mock_guess_service_name.return_value = "not_a_service"
    mock_validate_service_name.side_effect = NoSuchService(None)

    args = MagicMock()
    args.service = None
    expected_output = "%s\n" % NoSuchService.GUESS_ERROR_MSG

    assert paasta_generate_pipeline(args) == 1
    output = mock_stdout.getvalue().decode("utf-8")
    assert output == expected_output
Exemple #18
0
def test_generate_pipeline_success_with_no_opts(
    mock_log_audit,
    mock_generate_pipeline,
    mock_validate_service_name,
):
    # paasta generate succeeds when service name provided as arg
    mock_validate_service_name.return_value = None
    args = MagicMock()
    args.service = 'fake_service'
    assert paasta_generate_pipeline(args) is None
    mock_generate_pipeline.assert_called_once_with(service='fake_service',
                                                   soa_dir=ANY)
    mock_log_audit.assert_called_once_with(action='generate-pipeline',
                                           service='fake_service')
Exemple #19
0
def test_paasta_generate_pipeline_service_not_found(
        mock_stdout, mock_guess_service_name, mock_validate_service_name):
    # paasta generate cannot guess service name and none is provided

    mock_guess_service_name.return_value = 'not_a_service'
    mock_validate_service_name.side_effect = NoSuchService(None)

    args = MagicMock()
    args.service = None
    expected_output = "%s\n" % NoSuchService.GUESS_ERROR_MSG

    assert paasta_generate_pipeline(args) == 1
    output = mock_stdout.getvalue()
    assert output == expected_output
Exemple #20
0
def test_itest_works_when_service_name_starts_with_services_dash(
    mock_docker_image,
    mock_log,
    mock_build_docker_tag,
    mock_run,
    mock_validate_service_name,
):
    mock_docker_image.return_value = True
    mock_build_docker_tag.return_value = 'unused_docker_tag'
    mock_run.return_value = (0, 'Yeeehaaa')
    args = MagicMock()
    args.service = 'services-fake_service'
    args.commit = 'unused'
    assert paasta_itest(args) is 0
    mock_build_docker_tag.assert_called_once_with('fake_service', 'unused')
Exemple #21
0
def test_itest_works_when_service_name_starts_with_services_dash(
    mock_docker_image,
    mock_log,
    mock_build_docker_tag,
    mock_run,
    mock_validate_service_name,
):
    mock_docker_image.return_value = True
    mock_build_docker_tag.return_value = "unused_docker_tag"
    mock_run.return_value = (0, "Yeeehaaa")
    args = MagicMock()
    args.service = "services-fake_service"
    args.commit = "unused"
    assert paasta_itest(args) == 0
    mock_build_docker_tag.assert_called_once_with("fake_service", "unused")
Exemple #22
0
def test_itest_works_when_service_name_starts_with_services_dash(
    mock_docker_image,
    mock_log,
    mock_build_docker_tag,
    mock_run,
    mock_validate_service_name,
):
    mock_docker_image.return_value = True
    mock_build_docker_tag.return_value = 'unused_docker_tag'
    mock_run.return_value = (0, 'Yeeehaaa')
    args = MagicMock()
    args.service = 'services-fake_service'
    args.commit = 'unused'
    assert paasta_itest(args) == 0
    mock_build_docker_tag.assert_called_once_with('fake_service', 'unused')
Exemple #23
0
def test_paasta_generate_pipeline_success_guesses_service_name(
    mock_log_audit,
    mock_generate_pipeline,
    mock_guess_service_name,
    mock_validate_service_name,
):
    # paasta generate succeeds when service name must be guessed
    mock_guess_service_name.return_value = 'fake_service'
    mock_validate_service_name.return_value = None
    args = MagicMock()
    args.service = None
    assert paasta_generate_pipeline(args) is None
    mock_generate_pipeline.assert_called_once_with(service='fake_service',
                                                   soa_dir=ANY)
    mock_log_audit.assert_called_once_with(action='generate-pipeline',
                                           service='fake_service')
def test_status_arg_service_not_found(mock_stdout, mock_guess_service_name, mock_validate_service_name):
    # paasta_status with no args and non-service directory results in error
    mock_guess_service_name.return_value = "not_a_service"
    error = NoSuchService("fake_service")
    mock_validate_service_name.side_effect = error
    expected_output = str(error) + "\n"

    args = MagicMock()
    args.service = False

    # Fail if exit(1) does not get called
    with raises(SystemExit) as sys_exit:
        paasta_status(args)

    output = mock_stdout.getvalue()
    assert sys_exit.value.code == 1
    assert output == expected_output
def test_paasta_generate_pipeline_service_not_found(mock_stdout, mock_guess_service_name, mock_validate_service_name):
    # paasta generate cannot guess service name and none is provided

    mock_guess_service_name.return_value = "not_a_service"
    mock_validate_service_name.side_effect = NoSuchService(None)

    args = MagicMock()
    args.service = None
    expected_output = "%s\n" % NoSuchService.GUESS_ERROR_MSG

    # Fail if exit(1) does not get called
    with raises(SystemExit) as sys_exit:
        paasta_generate_pipeline(args)

    output = mock_stdout.getvalue()
    assert sys_exit.value.code == 1
    assert output == expected_output
Exemple #26
0
def test_status_calls_sergeants(
    mock_report_status,
    mock_get_planned_deployments,
    mock_get_actual_deployments,
    mock_figure_out_service_name,
    mock_load_system_paasta_config,
    capfd,
):
    service = 'fake_service'
    mock_figure_out_service_name.return_value = service

    planned_deployments = [
        'cluster1.instance1', 'cluster1.instance2', 'cluster2.instance1'
    ]
    mock_get_planned_deployments.return_value = planned_deployments

    actual_deployments = {
        'fake_service:paasta-cluster.instance': 'this_is_a_sha'
    }
    mock_get_actual_deployments.return_value = actual_deployments
    fake_system_paasta_config = utils.SystemPaastaConfig({}, '/fake/config')
    mock_load_system_paasta_config.return_value = fake_system_paasta_config
    mock_report_status.return_value = sentinel.return_value

    args = MagicMock()
    args.service = service
    args.clusters = None
    args.instances = None
    args.verbose = False
    args.soa_dir = '/fake/soa/dir'
    return_value = paasta_status(args)

    assert return_value == sentinel.return_value

    mock_figure_out_service_name.assert_called_once_with(args, '/fake/soa/dir')
    mock_get_actual_deployments.assert_called_once_with(
        service, '/fake/soa/dir')
    mock_report_status.assert_called_once_with(
        service=service,
        deploy_pipeline=planned_deployments,
        actual_deployments=actual_deployments,
        cluster_whitelist=[],
        instance_whitelist=[],
        system_paasta_config=fake_system_paasta_config,
        verbose=0,
        use_api_endpoint=False)
Exemple #27
0
def test_status_with_owner(
    mock_report_status,
    mock_load_system_paasta_config,
    mock_get_actual_deployments,
    mock_figure_out_service_name,
    mock_list_services,
    mock_get_instance_configs_for_service,
    system_paasta_config,
):
    mock_load_system_paasta_config.return_value = system_paasta_config
    mock_list_services.return_value = ['fakeservice', 'otherservice']
    cluster = 'fake_cluster'
    mock_inst_1 = make_fake_instance_conf(cluster,
                                          'fakeservice',
                                          'instance1',
                                          team='faketeam')
    mock_inst_2 = make_fake_instance_conf(cluster,
                                          'otherservice',
                                          'instance3',
                                          team='faketeam')
    mock_get_instance_configs_for_service.return_value = [
        mock_inst_1,
        mock_inst_2,
    ]

    mock_get_actual_deployments.return_value = {
        'fakeservice.instance1': 'sha1',
        'fakeservice.instance2': 'sha2',
        'otherservice.instance3': 'sha3',
        'otherservice.instance1': 'sha4',
    }
    mock_report_status.return_value = 0, ['dummy', 'output']

    args = MagicMock()
    args.service = None
    args.instances = None
    args.clusters = None
    args.deploy_group = None
    args.owner = 'faketeam'
    args.soa_dir = '/fake/soa/dir'
    args.registration = None
    return_value = paasta_status(args)

    assert return_value == 0
    assert mock_report_status.call_count == 2
Exemple #28
0
def test_status_arg_service_not_found(mock_stdout, mock_guess_service_name,
                                      mock_validate_service_name):
    # paasta_status with no args and non-service directory results in error
    mock_guess_service_name.return_value = 'not_a_service'
    error = NoSuchService('fake_service')
    mock_validate_service_name.side_effect = error
    expected_output = str(error) + "\n"

    args = MagicMock()
    args.service = False

    # Fail if exit(1) does not get called
    with raises(SystemExit) as sys_exit:
        paasta_status(args)

    output = mock_stdout.getvalue()
    assert sys_exit.value.code == 1
    assert output == expected_output
def test_paasta_generate_pipeline_service_not_found(
        mock_stdout, mock_guess_service_name, mock_validate_service_name):
    # paasta generate cannot guess service name and none is provided

    mock_guess_service_name.return_value = 'not_a_service'
    mock_validate_service_name.side_effect = NoSuchService(None)

    args = MagicMock()
    args.service = None
    expected_output = "%s\n" % NoSuchService.GUESS_ERROR_MSG

    # Fail if exit(1) does not get called
    with raises(SystemExit) as sys_exit:
        paasta_generate_pipeline(args)

    output = mock_stdout.getvalue()
    assert sys_exit.value.code == 1
    assert output == expected_output
Exemple #30
0
    def test_search_vm(self, suds_cli):
        client = MagicMock()
        service = MagicMock()
        vmrc_res = MagicMock()
        vmrc_res.name = "Image"
        vmrc_res.hypervisor = "qemu"
        vmrc_res.userPassword = "******"
        vmrc_res.userLogin = "******"
        vmrc_res.os = MagicMock()
        vmrc_res.os.name = "linux"
        vmrc_res.os.flavour = "ubuntu"
        vmrc_res.os.version = "14.04"
        vmrc_res.location = "one://server.com/1"
        service.search.return_value = [vmrc_res]
        client.service = service
        suds_cli.return_value = client

        vmrc = VMRC("http://host:8080/vmrc/vmrc", "user", "pass")

        radl_data = """
            network net ()
            system test (
            cpu.arch='x86_64' and
            cpu.count>=1 and
            memory.size>=512m and
            net_interface.0.connection = 'net' and
            disk.0.os.flavour='ubuntu' and
            disk.0.os.version>='12.04' and
            disk.applications contains (name = 'app' and version = '1.0') and
            soft 10 (disk.applications contains (name = 'otherapp' and version = '2.0'))
            )

            deploy test 1
            """
        radl = radl_parse.parse_radl(radl_data)

        res_radl = vmrc.search_vm(radl.systems[0])
        self.assertEqual(len(res_radl), 1)
        self.assertEqual(res_radl[0].getValue("disk.0.image.url"),
                         "one://server.com/1")
        self.assertEqual(
            res_radl[0].getValue("disk.0.os.credentials.password"), "pass")
        self.assertEqual(
            res_radl[0].getValue("disk.0.os.credentials.username"), "user")
def test_status_pending_pipeline_build_message(
    mock_stdout, mock_get_actual_deployments, mock_get_deploy_info, mock_figure_out_service_name
):
    # If deployments.json is missing SERVICE, output the appropriate message
    service = "fake_service"
    mock_figure_out_service_name.return_value = service
    pipeline = [{"instancename": "cluster.instance"}]
    mock_get_deploy_info.return_value = {"pipeline": pipeline}

    actual_deployments = {}
    mock_get_actual_deployments.return_value = actual_deployments
    expected_output = missing_deployments_message(service)

    args = MagicMock()
    args.service = service

    paasta_status(args)
    output = mock_stdout.getvalue()
    assert expected_output in output
Exemple #32
0
def test_status_pending_pipeline_build_message(
        mock_stdout, mock_get_actual_deployments, mock_get_deploy_info,
        mock_figure_out_service_name):
    # If deployments.json is missing SERVICE, output the appropriate message
    service = 'fake_service'
    mock_figure_out_service_name.return_value = service
    pipeline = [{'instancename': 'cluster.instance'}]
    mock_get_deploy_info.return_value = {'pipeline': pipeline}

    actual_deployments = {}
    mock_get_actual_deployments.return_value = actual_deployments
    expected_output = missing_deployments_message(service)

    args = MagicMock()
    args.service = service

    paasta_status(args)
    output = mock_stdout.getvalue()
    assert expected_output in output
Exemple #33
0
def test_status_calls_sergeants(
    mock_stdout,
    mock_report_status,
    mock_get_planned_deployments,
    mock_get_actual_deployments,
    mock_get_deploy_info,
    mock_figure_out_service_name,
):
    service = 'fake_service'
    mock_figure_out_service_name.return_value = service

    pipeline = [{'instancename': 'cluster.instance'}]
    deploy_info = {'pipeline': pipeline}
    planned_deployments = [
        'cluster1.instance1', 'cluster1.instance2', 'cluster2.instance1'
    ]
    mock_get_deploy_info.return_value = deploy_info
    mock_get_planned_deployments.return_value = planned_deployments

    actual_deployments = {
        'fake_service:paasta-cluster.instance': 'this_is_a_sha'
    }
    mock_get_actual_deployments.return_value = actual_deployments

    args = MagicMock()
    args.service = service
    args.clusters = None
    args.instances = None
    args.verbose = False
    paasta_status(args)

    mock_figure_out_service_name.assert_called_once_with(args)
    mock_get_actual_deployments.assert_called_once_with(service)
    mock_get_deploy_info.assert_called_once_with(service)
    mock_report_status.assert_called_once_with(
        service=service,
        deploy_pipeline=planned_deployments,
        actual_deployments=actual_deployments,
        cluster_whitelist=[],
        instance_whitelist=[],
        verbose=False,
    )
Exemple #34
0
def test_status_calls_sergeants(
    mock_stdout,
    mock_report_status,
    mock_get_planned_deployments,
    mock_get_actual_deployments,
    mock_figure_out_service_name,
    mock_load_system_paasta_config,
):
    service = 'fake_service'
    mock_figure_out_service_name.return_value = service

    planned_deployments = [
        'cluster1.instance1', 'cluster1.instance2', 'cluster2.instance1']
    mock_get_planned_deployments.return_value = planned_deployments

    actual_deployments = {
        'fake_service:paasta-cluster.instance': 'this_is_a_sha'
    }
    mock_get_actual_deployments.return_value = actual_deployments
    fake_system_paasta_config = utils.SystemPaastaConfig({}, '/fake/config')
    mock_load_system_paasta_config.return_value = fake_system_paasta_config

    args = MagicMock()
    args.service = service
    args.clusters = None
    args.instances = None
    args.verbose = False
    args.soa_dir = '/fake/soa/dir'
    paasta_status(args)

    mock_figure_out_service_name.assert_called_once_with(args, '/fake/soa/dir')
    mock_get_actual_deployments.assert_called_once_with(service, '/fake/soa/dir')
    mock_report_status.assert_called_once_with(
        service=service,
        deploy_pipeline=planned_deployments,
        actual_deployments=actual_deployments,
        cluster_whitelist=[],
        instance_whitelist=[],
        system_paasta_config=fake_system_paasta_config,
        verbose=0,
    )
Exemple #35
0
def test_status_pending_pipeline_build_message(
        mock_stdout, mock_get_actual_deployments, mock_get_deploy_info,
        mock_figure_out_service_name, mock_load_system_paasta_config):
    # If deployments.json is missing SERVICE, output the appropriate message
    service = 'fake_service'
    mock_figure_out_service_name.return_value = service
    pipeline = [{'instancename': 'cluster.instance'}]
    mock_get_deploy_info.return_value = {'pipeline': pipeline}
    fake_system_paasta_config = utils.SystemPaastaConfig({}, '/fake/config')
    mock_load_system_paasta_config.return_value = fake_system_paasta_config

    actual_deployments = {}
    mock_get_actual_deployments.return_value = actual_deployments
    expected_output = missing_deployments_message(service)

    args = MagicMock()
    args.service = service

    paasta_status(args)
    output = mock_stdout.getvalue()
    assert expected_output in output
Exemple #36
0
def test_rerun_validations(test_case):
    with contextlib.nested(
        patch('sys.stdout', new_callable=StringIO, autospec=None),
        patch('paasta_tools.cli.cmds.rerun.figure_out_service_name', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.list_clusters', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.get_actual_deployments', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.get_planned_deployments', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.execute_chronos_rerun_on_remote_master', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.chronos_tools.load_chronos_job_config', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.chronos_tools.uses_time_variables', autospec=True),
        patch('paasta_tools.cli.cmds.rerun._get_default_execution_date', autospec=True),
        patch('paasta_tools.cli.cmds.rerun.load_system_paasta_config', autospec=True),
    ) as (
        mock_stdout,
        mock_figure_out_service_name,
        mock_list_clusters,
        mock_get_actual_deployments,
        mock_get_planned_deployments,
        mock_execute_rerun_remote,
        mock_load_chronos_job_config,
        mock_uses_time_variables,
        mock_get_default_execution_date,
        mock_load_system_paasta_config,
    ):

        (rerun_args,
         mock_figure_out_service_name.return_value,
         mock_list_clusters.return_value,
         mock_get_actual_deployments.return_value,
         mock_get_planned_deployments.return_value,
         mock_uses_time_variables.return_value,
         expected_output) = test_case

        mock_load_chronos_job_config.return_value = {}
        default_date = datetime.datetime(2002, 2, 2, 2, 2, 2, 2)
        mock_get_default_execution_date.return_value = default_date
        mock_execute_rerun_remote.return_value = (0, '')
        mock_load_system_paasta_config.return_value = SystemPaastaConfig({}, '/fake/config')

        args = MagicMock()
        args.service = rerun_args[0]
        args.instance = rerun_args[1]
        args.clusters = rerun_args[2]
        if rerun_args[3]:
            args.execution_date = datetime.datetime.strptime(rerun_args[3], EXECUTION_DATE_FORMAT)
        else:
            args.execution_date = None
        args.verbose = 0

        paasta_rerun(args)

        # No --execution_date argument, but that's ok: the job doesn't use time vars interpolation.
        # Check if the backend rerun command was called with the default date.
        if args.execution_date is None and not mock_uses_time_variables.return_value:
            assert mock_execute_rerun_remote.call_args[1]['execution_date'] \
                == default_date.strftime(EXECUTION_DATE_FORMAT)

        # The job does use time vars interpolation. Make sure the User supplied date was used.
        if args.execution_date is not None and mock_uses_time_variables.return_value:
            assert mock_execute_rerun_remote.call_args[1]['execution_date'] == _user_supplied_execution_date

        output = mock_stdout.getvalue().decode('utf-8')
        assert expected_output in output
Exemple #37
0
def test_rerun_validations(test_case, capfd, system_paasta_config):
    with patch(
        'paasta_tools.cli.cmds.rerun.figure_out_service_name', autospec=True,
    ) as mock_figure_out_service_name, patch(
        'paasta_tools.cli.cmds.rerun.list_clusters', autospec=True,
    ) as mock_list_clusters, patch(
        'paasta_tools.cli.cmds.rerun.get_actual_deployments', autospec=True,
    ) as mock_get_actual_deployments, patch(
        'paasta_tools.cli.cmds.rerun.get_planned_deployments', autospec=True,
    ) as mock_get_planned_deployments, patch(
        'paasta_tools.cli.cmds.rerun.execute_chronos_rerun_on_remote_master', autospec=True,
    ) as mock_execute_rerun_remote, patch(
        'paasta_tools.cli.cmds.rerun.chronos_tools.load_chronos_job_config', autospec=True,
    ) as mock_load_chronos_job_config, patch(
        'paasta_tools.cli.cmds.rerun.chronos_tools.uses_time_variables', autospec=True,
    ) as mock_uses_time_variables, patch(
        'paasta_tools.cli.cmds.rerun._get_default_execution_date', autospec=True,
    ) as mock_get_default_execution_date, patch(
        'paasta_tools.cli.cmds.rerun.load_system_paasta_config', autospec=True,
    ) as mock_load_system_paasta_config, patch(
        'paasta_tools.chronos_tools.read_chronos_jobs_for_service', autospec=True,
    ) as mock_read_chronos_jobs_for_service, patch(
        'service_configuration_lib.read_services_configuration', autospec=True,
    ) as mock_read_services_configuration:
        (
            rerun_args,
            mock_figure_out_service_name.return_value,
            mock_list_clusters.return_value,
            mock_get_actual_deployments.return_value,
            mock_get_planned_deployments.return_value,
            mock_uses_time_variables.return_value,
            expected_output,
            call_execute_rerun_remote,
        ) = test_case

        def fake_load_chronos_jobs_config(service, instance, cluster, *args, **kwargs):
            mock = MagicMock(spec=ChronosJobConfig)
            if instance == 'dependent_instance2':
                mock.get_parents.return_value = ['{}.{}'.format(_service_name, 'dependent_instance1')]
            else:
                mock.get_parents.return_value = []
            return mock

        mock_load_chronos_job_config.side_effect = fake_load_chronos_jobs_config
        default_date = datetime.datetime(2002, 2, 2, 2, 2, 2, 2)
        mock_get_default_execution_date.return_value = default_date
        mock_execute_rerun_remote.return_value = (0, '')
        mock_load_system_paasta_config.return_value = system_paasta_config

        mock_read_chronos_jobs_for_service.return_value = {
            'instance1': {},
            'dependent_instance1': {},
            'dependent_instance2': {'parents': ['{}.{}'.format(_service_name, 'dependent_instance1')]},
        }

        mock_read_services_configuration.return_value = [_service_name]

        args = MagicMock()
        args.service = rerun_args[0]
        args.instance = rerun_args[1]
        args.clusters = rerun_args[2]
        if rerun_args[3]:
            args.execution_date = datetime.datetime.strptime(rerun_args[3], EXECUTION_DATE_FORMAT)
        else:
            args.execution_date = None
        args.rerun_type = rerun_args[4]
        args.force_disabled = rerun_args[5]
        args.verbose = 0

        paasta_rerun(args)

        # No --execution_date argument, but that's ok: the job doesn't use time vars interpolation.
        # Check if the backend rerun command was called with the default date.
        if args.execution_date is None and not mock_uses_time_variables.return_value:
            assert mock_execute_rerun_remote.call_args[1]['execution_date'] \
                == default_date.strftime(EXECUTION_DATE_FORMAT)

        if call_execute_rerun_remote:
            execution_date = args.execution_date if args.execution_date else default_date
            mock_execute_rerun_remote.assert_called_once_with(
                service=args.service,
                instancename=args.instance,
                cluster=mock.ANY,
                verbose=args.verbose,
                execution_date=execution_date.strftime(EXECUTION_DATE_FORMAT),
                run_all_related_jobs=bool(args.rerun_type and args.rerun_type == 'graph'),
                force_disabled=args.force_disabled,
                system_paasta_config=mock_load_system_paasta_config.return_value,
            )

        # The job does use time vars interpolation. Make sure the User supplied date was used.
        # TODO: this if statement is never true
        # if args.execution_date is not None and mock_uses_time_variables.return_value:
        #    assert mock_execute_rerun_remote.call_args[1]['execution_date'] == _user_supplied_execution_date

        output, _ = capfd.readouterr()
        assert expected_output in output