示例#1
0
文件: test_utils.py 项目: run-x/opta
def test_check_opta_file_exists_file_does_not_exists_user_input(
    mocker: MockFixture,
) -> None:
    mock_config_path = "mock_config_path"
    mock_user_config_path = "mock_user_config_path"
    mock_os_path_exists = mocker.patch(
        "opta.utils.os.path.exists", side_effect=[False, True]
    )
    mock_click_prompt = mocker.patch(
        "opta.utils.click.prompt", return_value=mock_user_config_path
    )
    mock_system_exit = mocker.patch("opta.utils.sys.exit")

    config_path = check_opta_file_exists(mock_config_path)

    assert config_path == mock_user_config_path
    mock_os_path_exists.assert_has_calls(
        [mocker.call(mock_config_path), mocker.call(mock_user_config_path)]
    )
    mock_click_prompt.assert_called_once_with(
        "Enter a Configuration Path (Empty String will exit)",
        default="",
        type=click.STRING,
        show_default=False,
    )
    mock_system_exit.assert_not_called()
    async def test_ok_filter_value_is_not_list(
            self, mocker: MockFixture,
            fake_model_data_provider: ModelDataProvider):
        fake_filters = dict(test=mocker.Mock())
        mocked_hasattr = mocker.patch(
            'aiohttp_baseapi.data_providers.model.hasattr',
            mocker.Mock(return_value=True))

        mocked_get_table_field = mocker.patch.object(fake_model_data_provider,
                                                     '_get_table_field')
        mocked_remove_comparison_suffix = mocker.patch.object(
            fake_model_data_provider, 'remove_comparison_suffix')
        mocked_get_filters = mocker.patch.object(
            fake_model_data_provider, 'get_filters',
            CoroutineMock(return_value=fake_filters))

        compared_where_list = await fake_model_data_provider.get_where_list()

        expected_where_list = [
            (mocked_get_table_field.return_value == filter_value)
            for filter_value in fake_filters.values()
        ]
        assert compared_where_list == expected_where_list
        mocked_get_table_field.has_calls(
            [mocker.call(filter_name) for filter_name in fake_filters.keys()])
        mocked_remove_comparison_suffix.has_calls([
            mocker.call(filter_value)
            for filter_value in fake_filters.values()
        ])
        mocked_hasattr.has_calls([
            mocker.call(fake_model_data_provider.model,
                        mocked_remove_comparison_suffix.return_value)
            for _ in fake_filters.keys()
        ])
        mocked_get_filters.assert_called_once()
示例#3
0
    def test_tail_module_log(self, mocker: MockFixture) -> None:
        base_start_time_timestamp = datetime.datetime.utcnow().timestamp()
        mocked_load_kube_config = mocker.patch(
            "opta.core.kubernetes.load_kube_config")
        mocked_core_v1_api = mocker.Mock(spec=CoreV1Api)
        mocked_core_v1_api_call = mocker.patch(
            "opta.core.kubernetes.CoreV1Api", return_value=mocked_core_v1_api)
        mocked_watch = mocker.Mock(spec=Watch)
        mocked_watch_call = mocker.patch("opta.core.kubernetes.Watch",
                                         return_value=mocked_watch)
        layer = mocker.Mock(spec=Layer)
        layer.name = "mocked_layer"
        layer.parent = None
        layer.providers = {
            "aws": {
                "region": "us-east-1",
                "account_id": "111111111111"
            }
        }
        mocked_pod_1 = mocker.Mock(spec=V1Pod)
        mocked_pod_1.metadata = mocker.Mock()
        mocked_pod_1.metadata.name = "pod1"
        mocked_pod_1.metadata.creation_timestamp = datetime.datetime.fromtimestamp(
            base_start_time_timestamp + 10000).replace(tzinfo=pytz.UTC)
        mocked_event_1 = {"object": mocked_pod_1}
        thread_1 = mocker.Mock()
        mocked_pod_2 = mocker.Mock(spec=V1Pod)
        mocked_pod_2.metadata = mocker.Mock()
        mocked_pod_2.metadata.name = "pod2"
        mocked_pod_2.metadata.creation_timestamp = datetime.datetime.fromtimestamp(
            base_start_time_timestamp + 10000).replace(tzinfo=pytz.UTC)
        mocked_event_2 = {"object": mocked_pod_2}
        thread_2 = mocker.Mock()
        mocked_watch.stream.return_value = [mocked_event_1, mocked_event_2]

        mocked_thread = mocker.patch("opta.core.kubernetes.Thread",
                                     side_effect=[thread_1, thread_2])

        tail_module_log(layer,
                        "mocked_module_name",
                        since_seconds=3,
                        start_color_idx=2)
        mocked_watch_call.assert_called_once_with()
        mocked_core_v1_api_call.assert_called_once_with()
        mocked_load_kube_config.assert_called_once_with(config_file=mocker.ANY)
        thread_1.start.assert_called_once_with()
        thread_2.start.assert_called_once_with()
        mocked_thread.assert_has_calls([
            mocker.call(
                target=tail_pod_log,
                args=("mocked_layer", mocked_pod_1, 2, 3),
                daemon=True,
            ),
            mocker.call(
                target=tail_pod_log,
                args=("mocked_layer", mocked_pod_2, 3, 3),
                daemon=True,
            ),
        ])
示例#4
0
    def test_google_download_state(self, mocker: MockFixture) -> None:
        layer = mocker.Mock(spec=Layer)
        layer.gen_providers.return_value = {
            "terraform": {
                "backend": {
                    "gcs": {
                        "bucket": "opta-tf-state-test-dev1",
                        "prefix": "dev1"
                    }
                }
            },
            "provider": {
                "google": {
                    "region": "us-central1",
                    "project": "dummy-project"
                }
            },
        }
        layer.name = "blah"
        layer.cloud = "google"
        mocker.patch("opta.core.terraform.Terraform._gcp_verify_storage",
                     return_value=True)
        patched_init = mocker.patch("opta.core.terraform.Terraform.init",
                                    return_value=True)
        mocked_credentials = mocker.Mock()
        mocked_gcp_credentials = mocker.patch(
            "opta.core.terraform.GCP.get_credentials",
            return_value=[mocked_credentials, "dummy-project"],
        )
        mocked_storage_client = mocker.Mock()
        mocked_client_constructor = mocker.patch(
            "opta.core.terraform.storage.Client",
            return_value=mocked_storage_client)
        mocked_bucket_object = mocker.Mock()
        mocked_storage_client.get_bucket.return_value = mocked_bucket_object
        read_data = '{"a": 1}'
        mocked_file = mocker.mock_open(read_data=read_data)
        mocker.patch("opta.core.terraform.os.remove")
        mocked_open = mocker.patch("opta.core.terraform.open", mocked_file)

        assert Terraform.download_state(layer)

        patched_init.assert_not_called()
        mocked_gcp_credentials.assert_called_once_with()
        mocked_client_constructor.assert_called_once_with(
            project="dummy-project", credentials=mocked_credentials)
        mocked_storage_client.get_bucket.assert_called_once_with(
            "opta-tf-state-test-dev1")
        mocked_open.assert_has_calls(
            [
                mocker.call("./tmp.tfstate", "wb"),
                mocker.call("./tmp.tfstate", "r")
            ],
            any_order=True,
        )
        mocked_storage_client.download_blob_to_file.assert_called_once_with(
            mocker.ANY, mocker.ANY)
示例#5
0
文件: test_push.py 项目: run-x/opta
def test_no_tag_override(mocker: MockFixture) -> None:
    # Opta file check
    mocked_os_path_exists = mocker.patch("opta.utils.os.path.exists")
    mocked_os_path_exists.return_value = True

    nice_run_mock = mocker.patch("opta.commands.push.nice_run")
    gen_mock = mocker.patch("opta.commands.push.gen_all")
    layer_object_mock = mocker.patch("opta.commands.push.Layer")
    layer_mock = mocker.Mock(spec=Layer)
    layer_mock.cloud = "aws"
    layer_mock.org_name = "dummy_org_name"
    layer_mock.name = "dummy_name"
    layer_object_mock.load_from_yaml.return_value = layer_mock
    mocker.patch(
        "opta.commands.push.get_registry_url"
    ).return_value = "889760294590.dkr.ecr.us-east-1.amazonaws.com/github-runx-app"
    mocker.patch("opta.commands.push.get_ecr_auth_info").return_value = (
        "username",
        "password",
    )
    mocker.patch("opta.commands.push.get_image_digest")

    runner = CliRunner()
    result = runner.invoke(cli, ["push", "local_image:local_tag"])

    assert result.exit_code == 0
    layer_object_mock.load_from_yaml.assert_called_once_with(
        "opta.yaml", None, input_variables={}
    )
    gen_mock.assert_called_once_with(layer_mock)

    nice_run_mock.assert_has_calls(
        [
            mocker.call(
                [
                    "docker",
                    "login",
                    "889760294590.dkr.ecr.us-east-1.amazonaws.com/github-runx-app",
                    "--username",
                    "username",
                    "--password-stdin",
                ],
                input=b"password",
                check=True,
            ),
            mocker.call(
                [
                    "docker",
                    "tag",
                    "local_image:local_tag",
                    "889760294590.dkr.ecr.us-east-1.amazonaws.com/github-runx-app:local_tag",
                ],
                check=True,
            ),
        ]
    )
示例#6
0
def test_chat_broadcast(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = ChatBot(send_message)
    bot.handle_message(10, 'hello')
    bot.handle_message(11, 'world')
    assert send_message.call_args_list == [
        mocker.call(10, '#10: hello'),
        mocker.call(10, '#11: world'),
        mocker.call(11, '#11: world'),
    ]
示例#7
0
def test_multiple_operations(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = CalculatorUserHandler(send_message)
    bot.handle_message('2 * 3')
    bot.handle_message('3 / 2')
    bot.handle_message('3 - 4')
    assert send_message.call_args_list == [
        mocker.call('6'),
        mocker.call('1'),
        mocker.call('-1')
    ]
示例#8
0
async def test_consume_messages(
    m_telebot: telebot.AsyncTeleBot,
    mocker: MockFixture,
) -> None:
    chat_id = 123456
    messages = [
        ExternalMessage(
            sender='@sender2',
            receiver='@receiver1',
            content='testing message 1',
        ),
        ExternalMessage(
            sender='@sender1',
            receiver='@receiver2',
            content='testing message 2',
        ),
    ]

    mocked_send_message = mocker.MagicMock()
    m_telebot.send_message.return_value = mocked_send_message
    mocked_send_message.wait.return_value = tb_types.Message(
        None,
        None,
        None,
        None,
        None,
        [],
        None,
    )

    bot = TelegramGroupChat(
        bot_token=FAKE_TOKEN,
        chat_id=chat_id,
    )
    await bot.consume_messages(messages)

    m_telebot.send_message.assert_has_calls(
        [
            mocker.call(
                chat_id,
                f'From {messages[0].sender} '
                f'to {messages[0].receiver}: '
                f'{messages[0].content}',
            ),
            mocker.call(
                chat_id,
                f'From {messages[1].sender} '
                f'to {messages[1].receiver}: '
                f'{messages[1].content}',
            ),
        ],
        any_order=True,
    )
示例#9
0
def test_tictactoe_wrong_arguments(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = TicTacToeUserHandler(send_message)
    bot.handle_message('start')
    bot.handle_message('X 0 0')
    bot.handle_message('X 1 0')
    bot.handle_message('O 0 0')
    assert send_message.call_args_list == [
        mocker.call('...\n...\n...'),
        mocker.call('X..\n...\n...'),
        mocker.call('Invalid turn'),
        mocker.call('Invalid turn'),
    ]
def test_game_many_starts(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = TicTacToeUserHandler(send_message)
    bot.handle_message('start')
    bot.handle_message('start')
    bot.handle_message('start')
    bot.handle_message('start')
    assert send_message.call_args_list == [
        mocker.call('...\n...\n...'),
        mocker.call('...\n...\n...'),
        mocker.call('...\n...\n...'),
        mocker.call('...\n...\n...')
    ]
def test_wrong_symbols(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = TicTacToeUserHandler(send_message)
    bot.handle_message('start')
    bot.handle_message('X 0 0')
    bot.handle_message('A 1 1')
    bot.handle_message('B 2 2')
    assert send_message.call_args_list == [
        mocker.call('...\n...\n...'),
        mocker.call('X..\n...\n...'),
        mocker.call('Invalid turn'),
        mocker.call('Invalid turn')
    ]
示例#12
0
文件: test_secret.py 项目: run-x/opta
    def test_list_secrets(self, mocker: MockFixture,
                          mocked_layer: Any) -> None:
        mocked_os_path_exists = mocker.patch("opta.utils.os.path.exists")
        mocked_os_path_exists.return_value = os.path.join(
            os.getcwd(), "tests", "fixtures", "dummy_data",
            "dummy_config1.yaml")
        mocked_print = mocker.patch("builtins.print")
        mocker.patch("opta.commands.secret.set_kube_config")

        mocked_create_namespace_if_not_exists = mocker.patch(
            "opta.commands.secret.create_namespace_if_not_exists")
        mocked_get_secret_name_and_namespace = mocker.patch(
            "opta.commands.secret.get_secret_name_and_namespace")
        mocked_get_secret_name_and_namespace.return_value = [
            "manual-secrets",
            "dummy_layer",
        ]
        mocked_get_secrets = mocker.patch("opta.commands.secret.get_secrets")
        mocked_get_secrets.return_value = {
            "dummysecret": "1",
            "b": "2",
            "c": "3"
        }

        mocked_amplitude_client = mocker.patch(
            "opta.commands.secret.amplitude_client", spec=AmplitudeClient)
        mocked_amplitude_client.LIST_SECRETS_EVENT = amplitude_client.LIST_SECRETS_EVENT

        runner = CliRunner()
        result = runner.invoke(
            list_command,
            ["--env", "dummyenv", "--config", "dummyconfig"],
        )
        assert result.exit_code == 0
        mocked_create_namespace_if_not_exists.assert_called_once_with(
            "dummy_layer")
        mocked_get_secrets.assert_called_once_with("dummy_layer",
                                                   "manual-secrets")
        mocked_layer.assert_called_once_with("dummyconfig",
                                             "dummyenv",
                                             input_variables={},
                                             strict_input_variables=False)
        mocked_amplitude_client.send_event.assert_called_once_with(
            amplitude_client.LIST_SECRETS_EVENT)
        mocked_print.assert_has_calls([
            mocker.call("dummysecret=1"),
            mocker.call("b=2"),
            mocker.call("c=3")
        ])
示例#13
0
    def test_add_admin_roles(self, mocker: MockFixture):
        layer = Layer.load_from_yaml(
            os.path.join(
                os.getcwd(), "tests", "fixtures", "dummy_data", "dummy_config_parent.yaml"
            ),
            None,
        )
        k8s_base_module = layer.get_module("k8sbase", 8)
        k8s_base_module.data["admin_arns"] = [
            "arn:aws:iam::445935066876:user/live-example-dev-live-example-dev-deployeruser",
            "arn:aws:iam::445935066876:role/live-example-dev-live-example-dev-deployerrole",
            "arn:aws:iam::445935066876:role/silly-role",
            "arn:aws:iam::445935066876:user/silly-user",
        ]

        mocker.patch("modules.aws_k8s_base.aws_k8s_base.set_kube_config")
        mocker.patch("modules.aws_k8s_base.aws_k8s_base.load_opta_kube_config")

        mocked_core_v1_api = mocker.Mock()
        mocker.patch(
            "modules.aws_k8s_base.aws_k8s_base.CoreV1Api",
            return_value=mocked_core_v1_api,
        )
        mocked_aws_auth_config_map = mocker.Mock()
        mocked_aws_auth_config_map.data = {
            "mapRoles": "- groups: ['system:bootstrappers', 'system:nodes']\n  rolearn: arn:aws:iam::445935066876:role/opta-live-example-dev-eks-default-node-group\n  username: system:node:{{EC2PrivateDNSName}}\n- groups: ['system:masters']\n  rolearn: arn:aws:iam::445935066876:role/live-example-dev-live-example-dev-deployerrole\n  username: opta-managed\n",
            "mapUsers": "- groups: ['system:masters']\n  userarn: arn:aws:iam::445935066876:user/live-example-dev-live-example-dev-deployeruser\n  username: opta-managed\n",
        }
        mocked_opta_arns_config_map = mocker.Mock()
        mocked_opta_arns_config_map.data = {
            "adminArns": '\n- "arn:aws:iam::445935066876:user/live-example-dev-live-example-dev-deployeruser"\n\n- "arn:aws:iam::445935066876:role/live-example-dev-live-example-dev-deployerrole"\n\n- "arn:aws:iam::445935066876:role/silly-role"\n\n- "arn:aws:iam::445935066876:user/silly-user"\n'
        }
        mocked_core_v1_api.read_namespaced_config_map.side_effect = [
            mocked_aws_auth_config_map,
            mocked_opta_arns_config_map,
        ]
        AwsK8sBaseProcessor(k8s_base_module, layer).add_admin_roles()
        mocked_core_v1_api.read_namespaced_config_map.assert_has_calls(
            [mocker.call("aws-auth", "kube-system"), mocker.call("opta-arns", "default")]
        )
        mocked_core_v1_api.replace_namespaced_config_map.assert_has_calls(
            [mocker.call("aws-auth", "kube-system", body=mocked_aws_auth_config_map)]
        )

        assert mocked_aws_auth_config_map.data == {
            "mapRoles": "- groups: ['system:bootstrappers', 'system:nodes']\n  rolearn: arn:aws:iam::445935066876:role/opta-live-example-dev-eks-default-node-group\n  username: system:node:{{EC2PrivateDNSName}}\n- groups: ['system:masters']\n  rolearn: arn:aws:iam::445935066876:role/live-example-dev-live-example-dev-deployerrole\n  username: opta-managed\n- groups: ['system:masters']\n  rolearn: arn:aws:iam::445935066876:role/silly-role\n  username: opta-managed\n",
            "mapUsers": "- groups: ['system:masters']\n  userarn: arn:aws:iam::445935066876:user/live-example-dev-live-example-dev-deployeruser\n  username: opta-managed\n- groups: ['system:masters']\n  userarn: arn:aws:iam::445935066876:user/silly-user\n  username: opta-managed\n",
        }
示例#14
0
def test_init_setup(with_scenarios, mocker: MockFixture):
    mock_resolve = mocker.patch("pydngconverter.compat.resolve_executable")
    mock_resolve.return_value = Path(""), ""
    dng = pydng.DNGConverter(*with_scenarios[0], **with_scenarios[-1])
    dng_call = mocker.call(["Adobe DNG Converter", "dngconverter"],
                           "PYDNG_DNG_CONVERTER")
    exif_call = mocker.call(["exiftool"], "PYDNG_EXIF_TOOL")
    if dng.parameters.jpeg_preview == flags.JPEGPreview.NONE:
        mock_resolve.assert_has_calls([dng_call])
        mock_resolve.assert_called_once()
    if dng.parameters.jpeg_preview == flags.JPEGPreview.MEDIUM:
        mock_resolve.assert_has_calls([dng_call])
        mock_resolve.assert_called_once()
    if dng.parameters.jpeg_preview == flags.JPEGPreview.EXTRACT:
        mock_resolve.assert_has_calls([dng_call, exif_call])
        assert mock_resolve.call_count == 2
示例#15
0
    async def test_ok(self, fake_rows, model_manager: BaseModelManager, mocker: MockFixture):
        fake_where_list = mocker.Mock()
        fake_order_by = mocker.Mock()
        fake_offset = mocker.Mock()
        fake_limit = mocker.Mock()
        mocked_row_class = mocker.patch.object(model_manager, 'row_class')
        mocked_get_items = mocker.patch.object(
            model_manager,
            'get_items',
            CoroutineMock(return_value=fake_rows)
        )

        actual_result = await model_manager.get_instances(
            where_list=fake_where_list,
            limit=fake_limit,
            offset=fake_offset,
            order_by=fake_order_by
        )

        expected_result = [mocked_row_class.return_value for _ in fake_rows]
        row_class_calls = [mocker.call(**row) for row in fake_rows]
        mocked_row_class.assert_has_calls(row_class_calls)
        mocked_get_items.assert_called_once_with(
            where_list=fake_where_list,
            limit=fake_limit,
            offset=fake_offset,
            order_by=fake_order_by
        )

        assert actual_result == expected_result
示例#16
0
    def test_post_hook_error(self, mocker: MockFixture):
        layer = Layer.load_from_yaml(
            os.path.join(
                os.getcwd(), "tests", "fixtures", "dummy_data", "dummy_config_parent.yaml"
            ),
            None,
        )
        aws_email_module = layer.get_module("awsses", 8)

        patched_logger = mocker.patch("modules.aws_ses.aws_ses.logger")
        mocked_sesv2 = mocker.Mock()
        mocked_boto3 = mocker.patch("modules.aws_ses.aws_ses.boto3")
        mocked_boto3.client.return_value = mocked_sesv2
        mocked_sesv2.get_account.return_value = {
            "ProductionAccessEnabled": False,
            "Details": {"ReviewDetails": {"Status": "FAILED", "CaseId": "123"}},
        }
        aws_dns_modules = layer.get_module("awsdns", 8)
        aws_dns_modules.data["delegated"] = True
        mocked_state_storage = mocker.patch("opta.layer.Layer.state_storage")
        mocked_state_storage.return_value = "whatever"
        AwsEmailProcessor(aws_email_module, layer).post_hook(8, None)
        mocked_boto3.client.assert_called_once()
        mocked_sesv2.get_account.assert_called_once()
        patched_logger.warning.assert_has_calls([mocker.call(mocker.ANY)])
        patched_logger.info.assert_not_called()
示例#17
0
    async def test_ok(self, model_manager: BaseModelManager, mocker: MockFixture):
        fake_values = [{'foo': 'bar'}]
        fake_fetchedall = [{'foo': 'bar'}]
        mocked_table = mocker.patch.object(model_manager, 'table', mocker.Mock(columns=[mocker.Mock(), mocker.Mock()]))
        mocked_set_sql = mocker.patch.object(model_manager, 'set_sql', return_value=model_manager)
        mocked_row_class = mocker.patch.object(model_manager, 'row_class')
        mocked_values = mocker.patch.object(model_manager, 'values', return_value=model_manager)
        mocked_returning = mocker.patch.object(model_manager, 'returning', return_value=model_manager)
        mocked_fetchall = mocker.patch.object(
            model_manager,
            'fetchall',
            CoroutineMock(return_value=fake_fetchedall)
        )

        compared_result = await model_manager.bulk_insert(fake_values)
        expected_result = [mocked_row_class.return_value for _ in fake_fetchedall]

        mocked_set_sql.assert_called_once_with(mocked_table.insert.return_value)
        mocked_table.insert.assert_called_once_with()
        mocked_values.assert_called_once_with(fake_values)
        mocked_returning.assert_called_once_with(*mocked_table.columns)
        mocked_fetchall.assert_called_once_with()

        row_class_calls = [mocker.call(**row) for row in fake_fetchedall]
        mocked_row_class.assert_has_calls(row_class_calls)

        assert compared_result == expected_result
示例#18
0
    def test_delete_persistent_volume_claims(self,
                                             mocker: MockFixture) -> None:
        mocked_core_v1_api = mocker.Mock(spec=CoreV1Api)
        mocker.patch("opta.core.kubernetes.CoreV1Api",
                     return_value=mocked_core_v1_api)
        mocker.patch("opta.core.kubernetes.load_kube_config")
        mocked_claim_opta1 = mocker.Mock(spec=V1PersistentVolumeClaim)
        mocked_claim_opta1.metadata = mocker.Mock()
        mocked_claim_opta1.metadata.name = "opta-claim-1"

        mocked_claim_opta2 = mocker.Mock(spec=V1PersistentVolumeClaim)
        mocked_claim_opta2.metadata = mocker.Mock()
        mocked_claim_opta2.metadata.name = "opta-claim-2"

        mocked_list_persistent_volume_claims = mocker.patch(
            "opta.core.kubernetes.list_persistent_volume_claims",
            return_value=[mocked_claim_opta1, mocked_claim_opta2],
        )

        # call with no parameter, expect list PVC method called and 2 delete PVC calls
        namespace = "hello"
        delete_persistent_volume_claims(namespace=namespace,
                                        opta_managed=True,
                                        async_req=True)
        mocked_list_persistent_volume_claims.assert_called_once_with(
            namespace="hello", opta_managed=True)

        mocked_core_v1_api.delete_collection_namespaced_persistent_volume_claim.assert_has_calls(
            [
                mocker.call(
                    namespace="hello",
                    field_selector="metadata.name=opta-claim-1",
                    async_req=True,
                    body=mocker.ANY,
                ),
                mocker.call(
                    namespace="hello",
                    field_selector="metadata.name=opta-claim-2",
                    async_req=True,
                    body=mocker.ANY,
                ),
            ])

        # pv are automatically deleted by k8s after deleting the claim, not by opta
        mocked_core_v1_api.assert_not_called()
示例#19
0
def test_tictactoe_winner_x(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = TicTacToeUserHandler(send_message)
    bot.handle_message('start')
    bot.handle_message('X 0 0')
    bot.handle_message('O 1 0')
    bot.handle_message('X 1 1')
    bot.handle_message('O 2 0')
    bot.handle_message('X 2 2')
    assert send_message.call_args_list == [
        mocker.call('...\n...\n...'),
        mocker.call('X..\n...\n...'),
        mocker.call('XO.\n...\n...'),
        mocker.call('XO.\n.X.\n...'),
        mocker.call('XOO\n.X.\n...'),
        mocker.call('XOO\n.X.\n..X'),
        mocker.call('Game is finished, X wins'),
    ]
def test_game_not_started(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = TicTacToeUserHandler(send_message)
    bot.handle_message('O 2 1')
    bot.handle_message('Hello')
    assert send_message.call_args_list == [
        mocker.call('Game is not started'),
        mocker.call('Game is not started')
    ]
示例#21
0
    def test_tail_pod_log(self, mocker: MockFixture) -> None:
        mocked_core_v1_api = mocker.Mock(spec=CoreV1Api)
        mocked_core_v1_api_call = mocker.patch(
            "opta.core.kubernetes.CoreV1Api", return_value=mocked_core_v1_api)
        mocked_watch = mocker.Mock(spec=Watch)
        mocked_watch_call = mocker.patch("opta.core.kubernetes.Watch",
                                         return_value=mocked_watch)
        mocked_watch.stream.side_effect = [
            "hello_world",
            ApiException(status=400),
            ApiException(status=400),
            ApiException(status=400),
            Exception(),
            ApiException(status=400),
        ]
        mocked_pod = mocker.Mock(spec=V1Pod)
        mocked_pod.metadata = mocker.Mock()
        mocked_pod.metadata.name = "pod1"
        mocked_time = mocker.patch("opta.core.kubernetes.time")

        tail_pod_log("mocked_namespace", mocked_pod, 2, 3)

        mocked_watch_call.assert_called_once_with()
        mocked_core_v1_api_call.assert_called_once_with()
        mocked_time.sleep.assert_has_calls([
            mocker.call(0),
            mocker.call(1),
            mocker.call(2),
            mocker.call(3),
            mocker.call(4),
            mocker.call(5),
            mocker.call(6),
            mocker.call(7),
            mocker.call(8),
            mocker.call(9),
            mocker.call(10),
            mocker.call(11),
            mocker.call(12),
            mocker.call(13),
            mocker.call(14),
        ])
        assert mocked_time.sleep.call_count == 15

        # Tailing should not retry upon encountering a 404 API exception.
        mocked_watch.stream.side_effect = [
            "hello_world",
            ApiException(status=400),
            ApiException(status=404),
        ]
        mocked_time = mocker.patch("opta.core.kubernetes.time")
        tail_pod_log("mocked_namespace", mocked_pod, 2, 3)
        assert mocked_time.sleep.call_count == 1
示例#22
0
    def test_process_new(self, mocker: MockFixture):
        layer = Layer.load_from_yaml(
            os.path.join(
                os.getcwd(), "tests", "fixtures", "dummy_data", "dummy_config_parent.yaml"
            ),
            None,
        )
        dns_module = layer.get_module("awsdns", 6)
        mocked_ssm = mocker.Mock()
        mocked_boto3 = mocker.patch("modules.aws_dns.aws_dns.boto3")
        mocked_boto3.client.return_value = mocked_ssm
        mocked_ssm.get_parameters_by_path.return_value = {"Parameters": []}

        patched_prompt = mocker.patch("modules.aws_dns.aws_dns.prompt")
        patched_prompt.side_effect = [
            os.path.join(os.getcwd(), "tests", "fixtures", "dummy_data", "dummy_key.pem"),
            os.path.join(
                os.getcwd(), "tests", "fixtures", "dummy_data", "dummy_cert.pem"
            ),
            "",
        ]
        mocked_state_storage = mocker.patch("opta.layer.Layer.state_storage")
        mocked_state_storage.return_value = "whatever"
        processor = AwsDnsProcessor(dns_module, layer)
        processor.process(2)
        mocked_boto3.client.assert_called_once_with("ssm", config=mocker.ANY)
        mocked_ssm.put_parameter.assert_has_calls(
            [
                mocker.call(
                    Name=mocker.ANY,
                    Value=mocker.ANY,
                    Type="SecureString",
                    Overwrite=True,
                ),
                mocker.call(
                    Name=mocker.ANY,
                    Value=mocker.ANY,
                    Type="SecureString",
                    Overwrite=True,
                ),
            ]
        )
示例#23
0
def test_run_configurations_async_mode(mocker: MockFixture, ) -> None:
    f_configurations = [mocker.MagicMock() for _ in range(2)]
    f_configuration_admin = ConfigurationAdmin(Configuration, AdminSite())

    f_run_configuration = mocker.patch('configuration.admin.run_configuration')

    f_configuration_admin.run_configurations(
        mocker.MagicMock(),
        f_configurations,
    )
    f_run_configuration.delay.assert_has_calls(
        [mocker.call(conf.id) for conf in f_configurations], )
示例#24
0
def test_tictactoe_draw(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = TicTacToeUserHandler(send_message)
    bot.handle_message('start')
    bot.handle_message('X 1 1')
    bot.handle_message('O 2 2')
    bot.handle_message('X 0 0')
    bot.handle_message('O 1 0')
    bot.handle_message('X 1 2')
    bot.handle_message('O 2 1')
    bot.handle_message('X 2 0')
    bot.handle_message('O 0 2')
    bot.handle_message('X 0 1')
    assert send_message.call_args_list == [
        mocker.call('...\n...\n...'),
        mocker.call('...\n.X.\n...'),
        mocker.call('...\n.X.\n..O'),
        mocker.call('X..\n.X.\n..O'),
        mocker.call('XO.\n.X.\n..O'),
        mocker.call('XO.\n.X.\n.XO'),
        mocker.call('XO.\n.XO\n.XO'),
        mocker.call('XOX\n.XO\n.XO'),
        mocker.call('XOX\n.XO\nOXO'),
        mocker.call('XOX\nXXO\nOXO'),
        mocker.call('Game is finished, draw'),
    ]
def test_x_wins(mocker: pytest_mock.MockFixture) -> None:
    send_message = mocker.stub(name='send_message_stub')
    bot = TicTacToeUserHandler(send_message)
    bot.handle_message('start')
    bot.handle_message('X 1 1')
    bot.handle_message('O 1 2')
    bot.handle_message('X 0 0')
    bot.handle_message('O 2 2')
    bot.handle_message('X 0 2')
    bot.handle_message('O 2 0')
    bot.handle_message('X 0 1')
    assert send_message.call_args_list == [
        mocker.call('...\n...\n...'),
        mocker.call('...\n.X.\n...'),
        mocker.call('...\n.X.\n.O.'),
        mocker.call('X..\n.X.\n.O.'),
        mocker.call('X..\n.X.\n.OO'),
        mocker.call('X..\n.X.\nXOO'),
        mocker.call('X.O\n.X.\nXOO'),
        mocker.call('X.O\nXX.\nXOO'),
        mocker.call('Game is finished, X wins')
    ]
示例#26
0
    def test_ok(self, mocker: MockFixture, fake_base_view_cls):
        fake_updated_value = 100

        fake_object = mocker.Mock(
            **{
                '_page.get.return_value': fake_updated_value,
                'MAX_LIMIT': 1000,
                'ITEMS_ON_PAGE': 100
            })
        mocker.patch.object(fake_object, '_page.update')
        fake_base_view_cls.validate_page(fake_object)

        fake_object._page.get.assert_has_calls([
            mocker.call('limit', fake_object.DEFAULT_LIMIT),
            mocker.call('offset', fake_object.DEFAULT_OFFSET),
        ])
        fake_object._page.update.assert_called_once_with({
            'limit':
            fake_updated_value,
            'offset':
            fake_updated_value
        })
示例#27
0
文件: test_push.py 项目: run-x/opta
def test_valid_input(mocker: MockFixture) -> None:
    mocker.patch("opta.commands.push.get_image_digest")
    mocked_nice_run = mocker.patch("opta.commands.push.nice_run")
    push_to_docker(
        "username",
        "password",
        "local_image:local_tag",
        REGISTRY_URL,
        "image_tag_override",
    )
    mocked_nice_run.assert_has_calls(
        [
            mocker.call(
                [
                    "docker",
                    "login",
                    REGISTRY_URL,
                    "--username",
                    "username",
                    "--password-stdin",
                ],
                input=b"password",
                check=True,
            ),
            mocker.call(
                [
                    "docker",
                    "tag",
                    "local_image:local_tag",
                    f"{REGISTRY_URL}:image_tag_override",
                ],
                check=True,
            ),
            mocker.call(
                ["docker", "push", f"{REGISTRY_URL}:image_tag_override"], check=True,
            ),
        ]
    )
示例#28
0
    def test_post_hook_prompt(self, mocker: MockFixture):
        layer = Layer.load_from_yaml(
            os.path.join(
                os.getcwd(), "tests", "fixtures", "dummy_data", "dummy_config_parent.yaml"
            ),
            None,
        )
        aws_email_module = layer.get_module("awsses", 8)

        patched_prompt = mocker.patch("modules.aws_ses.aws_ses.prompt")
        patched_prompt.side_effect = ["www.blah.com", "hello, world", "*****@*****.**"]
        patched_logger = mocker.patch("modules.aws_ses.aws_ses.logger")
        mocked_sesv2 = mocker.Mock()
        mocked_boto3 = mocker.patch("modules.aws_ses.aws_ses.boto3")
        mocked_boto3.client.return_value = mocked_sesv2
        mocked_sesv2.get_account.return_value = {
            "ProductionAccessEnabled": False,
        }
        mocked_state_storage = mocker.patch("opta.layer.Layer.state_storage")
        mocked_state_storage.return_value = "whatever"
        aws_dns_modules = layer.get_module("awsdns", 8)
        aws_dns_modules.data["delegated"] = True
        AwsEmailProcessor(aws_email_module, layer).post_hook(8, None)
        mocked_boto3.client.assert_called_once()
        mocked_sesv2.get_account.assert_called_once()
        mocked_sesv2.put_account_details.assert_called_once_with(
            MailType="TRANSACTIONAL",
            WebsiteURL="https://www.blah.com",
            ContactLanguage="EN",
            UseCaseDescription="hello, world",
            AdditionalContactEmailAddresses=["*****@*****.**"],
            ProductionAccessEnabled=True,
        )
        patched_logger.info.assert_has_calls(
            [mocker.call(mocker.ANY), mocker.call(mocker.ANY)]
        )
        patched_logger.warning.assert_not_called()
示例#29
0
        def test_ok(self, fake_columns, fake_row_model, mocker: MockFixture):
            fake_values = {col.key: mocker.Mock() for col in fake_columns}
            fake_row_model.__table__.columns = fake_columns
            mocked_get_value = mocker.patch.object(fake_row_model, '_get_value')
            expected_calls = []

            for col in fake_columns:
                setattr(fake_row_model, col.key, None)
                expected_calls.append(mocker.call(col.key))

            fake_row_model._set_values(fake_values)
            mocked_get_value.assert_has_calls(expected_calls, any_order=True)

            for key, value in fake_values.items():
                assert value == getattr(fake_row_model, key)
示例#30
0
    def test_ok_with_where_list(self, model_manager: BaseModelManager, mocker: MockFixture):
        fake_where_list = ['foo', 'bar']
        mocked_get_sql = mocker.Mock()

        mocker.patch.object(model_manager, 'get_sql', mocked_get_sql)
        mocker.patch.object(model_manager, 'sql')

        model_manager.where(fake_where_list)

        compared_sql = model_manager.sql
        expected_sql = mocked_get_sql.return_value.where.return_value

        calls = [mocker.call(where) for where in fake_where_list]
        mocked_get_sql.return_value.where.assert_has_calls(calls)

        assert compared_sql == expected_sql