diff --git a/examples/clickpipe/externally_managed_table/provider.tf b/examples/clickpipe/externally_managed_table/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/externally_managed_table/provider.tf +++ b/examples/clickpipe/externally_managed_table/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/kafka_azure_eventhub/provider.tf b/examples/clickpipe/kafka_azure_eventhub/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/kafka_azure_eventhub/provider.tf +++ b/examples/clickpipe/kafka_azure_eventhub/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/kafka_confluent/provider.tf b/examples/clickpipe/kafka_confluent/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/kafka_confluent/provider.tf +++ b/examples/clickpipe/kafka_confluent/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/kafka_msk_iam_role/provider.tf b/examples/clickpipe/kafka_msk_iam_role/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/kafka_msk_iam_role/provider.tf +++ b/examples/clickpipe/kafka_msk_iam_role/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/kafka_msk_iam_user/provider.tf b/examples/clickpipe/kafka_msk_iam_user/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/kafka_msk_iam_user/provider.tf +++ b/examples/clickpipe/kafka_msk_iam_user/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/kafka_offset_strategy/provider.tf b/examples/clickpipe/kafka_offset_strategy/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/kafka_offset_strategy/provider.tf +++ b/examples/clickpipe/kafka_offset_strategy/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/kafka_redpanda_scram/provider.tf b/examples/clickpipe/kafka_redpanda_scram/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/kafka_redpanda_scram/provider.tf +++ b/examples/clickpipe/kafka_redpanda_scram/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/kafka_schema_registry/provider.tf b/examples/clickpipe/kafka_schema_registry/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/kafka_schema_registry/provider.tf +++ b/examples/clickpipe/kafka_schema_registry/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/multiple_pipes_example/provider.tf b/examples/clickpipe/multiple_pipes_example/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/multiple_pipes_example/provider.tf +++ b/examples/clickpipe/multiple_pipes_example/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/object_storage_iam_role/provider.tf b/examples/clickpipe/object_storage_iam_role/provider.tf index 07ff37f3..51e95dbf 100644 --- a/examples/clickpipe/object_storage_iam_role/provider.tf +++ b/examples/clickpipe/object_storage_iam_role/provider.tf @@ -11,13 +11,9 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/object_storage_iam_user/provider.tf b/examples/clickpipe/object_storage_iam_user/provider.tf index 07ff37f3..7d86780f 100644 --- a/examples/clickpipe/object_storage_iam_user/provider.tf +++ b/examples/clickpipe/object_storage_iam_user/provider.tf @@ -11,13 +11,10 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} + provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/clickpipe/reverse_private_endpoint_msk/main.tf b/examples/clickpipe/reverse_private_endpoint_msk/main.tf new file mode 100644 index 00000000..e03d587e --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_msk/main.tf @@ -0,0 +1,39 @@ +variable "service_id" { + description = "ClickHouse service ID" +} + +variable "msk_cluster_arn" { + description = "MSK cluter ARN" +} + +variable "msk_authentication" { + description = "MSK authentication" + default = "SASL_SCRAM" +} + +resource "clickhouse_clickpipes_reverse_private_endpoint" "endpoint" { + service_id = var.service_id + description = "Reverse private endpoint for ClickPipes" + type = "MSK_MULTI_VPC" + msk_cluster_arn = var.msk_cluster_arn + msk_authentication = var.msk_authentication +} + +output "id" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.id +} + +output "msk_vpc_connection_id" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.endpoint_id +} + +output "dns_names" { + value = concat( + clickhouse_clickpipes_reverse_private_endpoint.endpoint.dns_names != null ? clickhouse_clickpipes_reverse_private_endpoint.endpoint.dns_names : [], + clickhouse_clickpipes_reverse_private_endpoint.endpoint.private_dns_names != null ? clickhouse_clickpipes_reverse_private_endpoint.endpoint.private_dns_names : [] + ) +} + +output "status" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.status +} diff --git a/examples/clickpipe/reverse_private_endpoint_msk/provider.tf b/examples/clickpipe/reverse_private_endpoint_msk/provider.tf new file mode 100644 index 00000000..51e95dbf --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_msk/provider.tf @@ -0,0 +1,19 @@ +# This file is generated automatically please do not edit +terraform { + required_providers { + clickhouse = { + version = "2.0.0-alpha1" + source = "ClickHouse/clickhouse" + } + } +} + +variable "organization_id" {} +variable "token_key" {} +variable "token_secret" {} + +provider "clickhouse" { + organization_id = var.organization_id + token_key = var.token_key + token_secret = var.token_secret +} diff --git a/examples/clickpipe/reverse_private_endpoint_msk/variables.sample.tfvars b/examples/clickpipe/reverse_private_endpoint_msk/variables.sample.tfvars new file mode 100644 index 00000000..05f340a8 --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_msk/variables.sample.tfvars @@ -0,0 +1,8 @@ +# these keys are for example only and won't work when pointed to a deployed ClickHouse OpenAPI server +organization_id = "aee076c1-3f83-4637-95b1-ad5a0a825b71" +token_key = "avhj1U5QCdWAE9CA9" +token_secret = "4b1dROiHQEuSXJHlV8zHFd0S7WQj7CGxz5kGJeJnca" +service_id = "aee076c1-3f83-4637-95b1-ad5a0a825b71" + +msk_cluster_arn = "arn:aws:kafka:us-east-2:123456789012:cluster/ExampleCluster/12345678-1234-1234-1234-123456789012-1" +msk_authentication = "SASL_SCRAM" # or SASL_IAM \ No newline at end of file diff --git a/examples/clickpipe/reverse_private_endpoint_msk_pipe/clickpipe.tf b/examples/clickpipe/reverse_private_endpoint_msk_pipe/clickpipe.tf new file mode 100644 index 00000000..ba55af97 --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_msk_pipe/clickpipe.tf @@ -0,0 +1,68 @@ +locals { + // MSK brokers for multi-VPC connectivity ports starting from 14001 incremented by a broker number + msk_brokers = [for i, dns in clickhouse_clickpipes_reverse_private_endpoint.endpoint.private_dns_names : "${dns}:${i + 14001}"] +} + +resource "clickhouse_clickpipe" "msk" { + name = "MSK pipe using Reverse Private Endpoint" + description = "This pipe is using a secure private endpoint to connect to MSK" + + service_id = var.service_id + + scaling = { + replicas = 1 + } + + state = "Running" + + source = { + kafka = { + type = "msk" + format = "JSONEachRow" + brokers = join(",", local.msk_brokers) + topics = var.kafka_topic + + authentication = var.msk_authentication + credentials = { + username = var.msk_scram_user + password = var.msk_scram_password + } + + reverse_private_endpoint_ids = [ + clickhouse_clickpipes_reverse_private_endpoint.endpoint.id + ] + } + } + + destination = { + table = "my_table" + managed_table = true + + table_definition = { + engine = { + type = "MergeTree" + } + } + + columns = [ + { + name = "my_field1" + type = "String" + }, { + name = "my_field2" + type = "UInt64" + } + ] + } + + field_mappings = [ + { + source_field = "my_field" + destination_field = "my_field1" + } + ] +} + +output "clickpipe_id" { + value = clickhouse_clickpipe.msk.id +} \ No newline at end of file diff --git a/examples/clickpipe/reverse_private_endpoint_msk_pipe/provider.tf b/examples/clickpipe/reverse_private_endpoint_msk_pipe/provider.tf new file mode 100644 index 00000000..51e95dbf --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_msk_pipe/provider.tf @@ -0,0 +1,19 @@ +# This file is generated automatically please do not edit +terraform { + required_providers { + clickhouse = { + version = "2.0.0-alpha1" + source = "ClickHouse/clickhouse" + } + } +} + +variable "organization_id" {} +variable "token_key" {} +variable "token_secret" {} + +provider "clickhouse" { + organization_id = var.organization_id + token_key = var.token_key + token_secret = var.token_secret +} diff --git a/examples/clickpipe/reverse_private_endpoint_msk_pipe/reverse_private_endpoint.tf b/examples/clickpipe/reverse_private_endpoint_msk_pipe/reverse_private_endpoint.tf new file mode 100644 index 00000000..647c0e8b --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_msk_pipe/reverse_private_endpoint.tf @@ -0,0 +1,27 @@ +locals { + rpe_msk_authentication_mapping = { + "SCRAM-SHA-512" = "SASL_SCRAM" + "IAM_ROLE" = "SASL_IAM" + "IAM_USER" = "SASL_IAM" + } + + // In this example we map from a ClickPipe authentication method + // into a MSK multi-VPC authentication method. + rpe_msk_authentication = local.rpe_msk_authentication_mapping[var.msk_authentication] +} + +resource "clickhouse_clickpipes_reverse_private_endpoint" "endpoint" { + service_id = var.service_id + description = "Reverse private endpoint for my ClickPipe" + type = "MSK_MULTI_VPC" + msk_cluster_arn = var.msk_cluster_arn + msk_authentication = local.rpe_msk_authentication +} + +output "reverse_private_endpoint_id" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.id +} + +output "msk_vpc_connection_id" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.endpoint_id +} diff --git a/examples/clickpipe/reverse_private_endpoint_msk_pipe/variables.sample.tfvars b/examples/clickpipe/reverse_private_endpoint_msk_pipe/variables.sample.tfvars new file mode 100644 index 00000000..cab6c070 --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_msk_pipe/variables.sample.tfvars @@ -0,0 +1,11 @@ +# these keys are for example only and won't work when pointed to a deployed ClickHouse OpenAPI server +organization_id = "aee076c1-3f83-4637-95b1-ad5a0a825b71" +token_key = "avhj1U5QCdWAE9CA9" +token_secret = "4b1dROiHQEuSXJHlV8zHFd0S7WQj7CGxz5kGJeJnca" +service_id = "aee076c1-3f83-4637-95b1-ad5a0a825b71" + +msk_cluster_arn = "arn:aws:kafka:us-east-2:123456789012:cluster/ExampleCluster/12345678-1234-1234-1234-123456789012-1" +msk_authentication = "SASL_SCRAM" # or SASL_IAM +msk_scram_user = "example_user" +msk_scram_password = "example_password" +kafka_topic = "example_topic" \ No newline at end of file diff --git a/examples/clickpipe/reverse_private_endpoint_msk_pipe/vars.tf b/examples/clickpipe/reverse_private_endpoint_msk_pipe/vars.tf new file mode 100644 index 00000000..e58a0a9f --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_msk_pipe/vars.tf @@ -0,0 +1,27 @@ +variable "service_id" { + description = "ClickHouse service ID" +} + +variable "msk_cluster_arn" { + description = "MSK cluter ARN" +} + +variable "msk_authentication" { + description = "MSK authentication" + default = "SCRAM-SHA-512" # or IAM_USER or IAM_ROLE +} + +variable "msk_scram_user" { + description = "MSK scram user" + default = "scram_user" +} + +variable "msk_scram_password" { + description = "MSK scram password" + default = "scram_password" +} + +variable "kafka_topic" { + description = "Kafka topic" + default = "my_topic" +} diff --git a/examples/clickpipe/reverse_private_endpoint_vpc_resource/main.tf b/examples/clickpipe/reverse_private_endpoint_vpc_resource/main.tf new file mode 100644 index 00000000..e7b62461 --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_vpc_resource/main.tf @@ -0,0 +1,38 @@ +variable "service_id" { + description = "ClickHouse service ID" +} + +variable "vpc_resource_configuration_id" { + description = "VPC resource configuration id" +} + +variable "vpc_resource_share_arn" { + description = "VPC resource share ARN" +} + +resource "clickhouse_clickpipes_reverse_private_endpoint" "endpoint" { + service_id = var.service_id + description = "Reverse private endpoint for ClickPipes" + type = "VPC_RESOURCE" + vpc_resource_configuration_id = var.vpc_resource_configuration_id + vpc_resource_share_arn = var.vpc_resource_share_arn +} + +output "id" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.id +} + +output "endpoint_id" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.endpoint_id +} + +output "dns_names" { + value = concat( + clickhouse_clickpipes_reverse_private_endpoint.endpoint.dns_names, + clickhouse_clickpipes_reverse_private_endpoint.endpoint.private_dns_names != null ? clickhouse_clickpipes_reverse_private_endpoint.endpoint.private_dns_names : [] + ) +} + +output "status" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.status +} diff --git a/examples/clickpipe/reverse_private_endpoint_vpc_resource/provider.tf b/examples/clickpipe/reverse_private_endpoint_vpc_resource/provider.tf new file mode 100644 index 00000000..51e95dbf --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_vpc_resource/provider.tf @@ -0,0 +1,19 @@ +# This file is generated automatically please do not edit +terraform { + required_providers { + clickhouse = { + version = "2.0.0-alpha1" + source = "ClickHouse/clickhouse" + } + } +} + +variable "organization_id" {} +variable "token_key" {} +variable "token_secret" {} + +provider "clickhouse" { + organization_id = var.organization_id + token_key = var.token_key + token_secret = var.token_secret +} diff --git a/examples/clickpipe/reverse_private_endpoint_vpc_resource/variables.sample.tfvars b/examples/clickpipe/reverse_private_endpoint_vpc_resource/variables.sample.tfvars new file mode 100644 index 00000000..6b4c8ca4 --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_vpc_resource/variables.sample.tfvars @@ -0,0 +1,8 @@ +# these keys are for example only and won't work when pointed to a deployed ClickHouse OpenAPI server +organization_id = "aee076c1-3f83-4637-95b1-ad5a0a825b71" +token_key = "avhj1U5QCdWAE9CA9" +token_secret = "4b1dROiHQEuSXJHlV8zHFd0S7WQj7CGxz5kGJeJnca" +service_id = "aee076c1-3f83-4637-95b1-ad5a0a825b71" + +vpc_resource_configuration_id = "rcfg-1234567890abcdef" +vpc_resource_share_arn = "arn:aws:ram:us-east-2:123456789012:resource-share/12345678-1234-1234-1234-123456789012" \ No newline at end of file diff --git a/examples/clickpipe/reverse_private_endpoint_vpce_service/main.tf b/examples/clickpipe/reverse_private_endpoint_vpce_service/main.tf new file mode 100644 index 00000000..c58f8bd7 --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_vpce_service/main.tf @@ -0,0 +1,33 @@ +variable "service_id" { + description = "ClickHouse service ID" +} + +variable "vpc_endpoint_service_name" { + description = "VPC endpoint service name" +} + +resource "clickhouse_clickpipes_reverse_private_endpoint" "endpoint" { + service_id = var.service_id + description = "Reverse private endpoint for ClickPipes" + type = "VPC_ENDPOINT_SERVICE" + vpc_endpoint_service_name = var.vpc_endpoint_service_name +} + +output "id" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.id +} + +output "endpoint_id" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.endpoint_id +} + +output "dns_names" { + value = concat( + clickhouse_clickpipes_reverse_private_endpoint.endpoint.dns_names, + clickhouse_clickpipes_reverse_private_endpoint.endpoint.private_dns_names != null ? clickhouse_clickpipes_reverse_private_endpoint.endpoint.private_dns_names : [] + ) +} + +output "status" { + value = clickhouse_clickpipes_reverse_private_endpoint.endpoint.status +} diff --git a/examples/clickpipe/reverse_private_endpoint_vpce_service/provider.tf b/examples/clickpipe/reverse_private_endpoint_vpce_service/provider.tf new file mode 100644 index 00000000..51e95dbf --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_vpce_service/provider.tf @@ -0,0 +1,19 @@ +# This file is generated automatically please do not edit +terraform { + required_providers { + clickhouse = { + version = "2.0.0-alpha1" + source = "ClickHouse/clickhouse" + } + } +} + +variable "organization_id" {} +variable "token_key" {} +variable "token_secret" {} + +provider "clickhouse" { + organization_id = var.organization_id + token_key = var.token_key + token_secret = var.token_secret +} diff --git a/examples/clickpipe/reverse_private_endpoint_vpce_service/variables.sample.tfvars b/examples/clickpipe/reverse_private_endpoint_vpce_service/variables.sample.tfvars new file mode 100644 index 00000000..e75abe13 --- /dev/null +++ b/examples/clickpipe/reverse_private_endpoint_vpce_service/variables.sample.tfvars @@ -0,0 +1,7 @@ +# these keys are for example only and won't work when pointed to a deployed ClickHouse OpenAPI server +organization_id = "aee076c1-3f83-4637-95b1-ad5a0a825b71" +token_key = "avhj1U5QCdWAE9CA9" +token_secret = "4b1dROiHQEuSXJHlV8zHFd0S7WQj7CGxz5kGJeJnca" +service_id = "aee076c1-3f83-4637-95b1-ad5a0a825b71" + +vpc_endpoint_service_name = "com.amazonaws.us-east-2.vpce-svc-0a1b2c3d4e5f6g7h8" \ No newline at end of file diff --git a/examples/clickpipe/service_and_clickpipe/provider.tf b/examples/clickpipe/service_and_clickpipe/provider.tf index 07ff37f3..51e95dbf 100644 --- a/examples/clickpipe/service_and_clickpipe/provider.tf +++ b/examples/clickpipe/service_and_clickpipe/provider.tf @@ -11,13 +11,9 @@ terraform { variable "organization_id" {} variable "token_key" {} variable "token_secret" {} -variable "api_url" { - default = "https://api.clickhouse.cloud/v1" -} provider "clickhouse" { organization_id = var.organization_id token_key = var.token_key token_secret = var.token_secret - api_url = var.api_url } diff --git a/examples/resources/clickhouse_clickpipes_reverse_private_endpoint/resource.tf b/examples/resources/clickhouse_clickpipes_reverse_private_endpoint/resource.tf new file mode 100644 index 00000000..79f2fc05 --- /dev/null +++ b/examples/resources/clickhouse_clickpipes_reverse_private_endpoint/resource.tf @@ -0,0 +1,22 @@ +resource "clickhouse_clickpipes_reverse_private_endpoint" "vpc_endpoint_service" { + service_id = "3a10a385-ced2-452e-abb8-908c80976a8f" + description = "VPC_ENDPOINT_SERVICE reverse private endpoint for ClickPipes" + type = "VPC_ENDPOINT_SERVICE" + vpc_endpoint_service_name = "com.amazonaws.vpce.eu-west-1.vpce-svc-080826a65b5b27d4e" +} + +resource "clickhouse_clickpipes_reverse_private_endpoint" "vpc_resource" { + service_id = "3a10a385-ced2-452e-abb8-908c80976a8f" + description = "VPC_RESOURCE reverse private endpoint for ClickPipes" + type = "VPC_RESOURCE" + vpc_resource_configuration_id = "rcfg-1a2b3c4d5e6f7g8h9" + vpc_resource_share_arn = "arn:aws:ram:us-east-1:123456789012:resource-share/1a2b3c4d-5e6f-7g8h-9i0j-k1l2m3n4o5p6" +} + +resource "clickhouse_clickpipes_reverse_private_endpoint" "msk_multi_vpc" { + service_id = "3a10a385-ced2-452e-abb8-908c80976a8f" + description = "MSK_MULTI_VPC reverse private endpoint for ClickPipes" + type = "MSK_MULTI_VPC" + msk_cluster_arn = "arn:aws:kafka:us-east-1:123456789012:cluster/ClickHouse-Cluster/1a2b3c4d-5e6f-7g8h-9i0j-k1l2m3n4o5p6-1" + msk_authentication = "SASL_IAM" +} diff --git a/pkg/internal/api/clickpipe_models.go b/pkg/internal/api/clickpipe_models.go index 4df6f3ed..62d9e38c 100644 --- a/pkg/internal/api/clickpipe_models.go +++ b/pkg/internal/api/clickpipe_models.go @@ -51,6 +51,8 @@ type ClickPipeKafkaSource struct { Credentials *ClickPipeKafkaSourceCredentials `json:"credentials,omitempty"` IAMRole *string `json:"iamRole,omitempty"` CACertificate *string `json:"caCertificate,omitempty"` + + ReversePrivateEndpointIDs []string `json:"reversePrivateEndpointIds,omitempty"` } type ClickPipeObjectStorageSource struct { diff --git a/pkg/internal/api/clickpipe_reverse_private_endpoint.go b/pkg/internal/api/clickpipe_reverse_private_endpoint.go new file mode 100644 index 00000000..a27a152b --- /dev/null +++ b/pkg/internal/api/clickpipe_reverse_private_endpoint.go @@ -0,0 +1,162 @@ +package api + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "net/http" + "time" + + "github.com/cenkalti/backoff/v4" +) + +const ( + ReversePrivateEndpointTypeVPCEndpointService = "VPC_ENDPOINT_SERVICE" + ReversePrivateEndpointTypeVPCResource = "VPC_RESOURCE" + ReversePrivateEndpointTypeMSKMultiVPC = "MSK_MULTI_VPC" +) + +const ( + MSKAuthenticationSASLIAM = "SASL_IAM" + MSKAuthenticationSASLSCRAM = "SASL_SCRAM" +) + +const ( + ReversePrivateEndpointStatusUnknown = "Unknown" + ReversePrivateEndpointStatusProvisioning = "Provisioning" + ReversePrivateEndpointStatusDeleting = "Deleting" + ReversePrivateEndpointStatusReady = "Ready" + ReversePrivateEndpointStatusFailed = "Failed" + ReversePrivateEndpointStatusPendingAcceptance = "PendingAcceptance" + ReversePrivateEndpointStatusRejected = "Rejected" + ReversePrivateEndpointStatusExpired = "Expired" +) + +var ( + ReversePrivateEndpointTypes = []string{ + ReversePrivateEndpointTypeVPCEndpointService, + ReversePrivateEndpointTypeVPCResource, + ReversePrivateEndpointTypeMSKMultiVPC, + } + + MSKAuthenticationTypes = []string{ + MSKAuthenticationSASLIAM, + MSKAuthenticationSASLSCRAM, + } + + ReversePrivateEndpointStatuses = []string{ + ReversePrivateEndpointStatusUnknown, + ReversePrivateEndpointStatusProvisioning, + ReversePrivateEndpointStatusDeleting, + ReversePrivateEndpointStatusReady, + ReversePrivateEndpointStatusFailed, + ReversePrivateEndpointStatusPendingAcceptance, + ReversePrivateEndpointStatusRejected, + ReversePrivateEndpointStatusExpired, + } +) + +func (c *ClientImpl) GetReversePrivateEndpointPath(serviceId, reversePrivateEndpointId string) string { + return c.getServicePath(serviceId, fmt.Sprintf("/clickpipesReversePrivateEndpoints/%s", reversePrivateEndpointId)) +} + +func (c *ClientImpl) ListReversePrivateEndpoints(ctx context.Context, serviceId string) ([]*ReversePrivateEndpoint, error) { + req, err := http.NewRequest(http.MethodGet, c.getServicePath(serviceId, "/clickpipesReversePrivateEndpoints"), nil) + if err != nil { + return nil, err + } + + body, err := c.doRequest(ctx, req) + if err != nil { + return nil, err + } + + response := ResponseWithResult[[]ReversePrivateEndpoint]{} + if err := json.Unmarshal(body, &response); err != nil { + return nil, fmt.Errorf("failed to unmarshal ReversePrivateEndpoints: %w", err) + } + + result := make([]*ReversePrivateEndpoint, len(response.Result)) + for i, rpe := range response.Result { + // Copy for proper reference + result[i] = &rpe + } + + return result, nil +} + +func (c *ClientImpl) GetReversePrivateEndpoint(ctx context.Context, serviceId, reversePrivateEndpointId string) (*ReversePrivateEndpoint, error) { + req, err := http.NewRequest(http.MethodGet, c.GetReversePrivateEndpointPath(serviceId, reversePrivateEndpointId), nil) + if err != nil { + return nil, err + } + + body, err := c.doRequest(ctx, req) + if err != nil { + return nil, err + } + + response := ResponseWithResult[ReversePrivateEndpoint]{} + if err := json.Unmarshal(body, &response); err != nil { + return nil, fmt.Errorf("failed to unmarshal ReversePrivateEndpoint: %w", err) + } + + return &response.Result, nil +} + +func (c *ClientImpl) CreateReversePrivateEndpoint(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint) (*ReversePrivateEndpoint, error) { + var payload bytes.Buffer + if err := json.NewEncoder(&payload).Encode(request); err != nil { + return nil, fmt.Errorf("failed to encode ReversePrivateEndpoint: %w", err) + } + + req, err := http.NewRequest(http.MethodPost, c.getServicePath(serviceId, "/clickpipesReversePrivateEndpoints"), &payload) + if err != nil { + return nil, err + } + + body, err := c.doRequest(ctx, req) + if err != nil { + return nil, err + } + + response := ResponseWithResult[ReversePrivateEndpoint]{} + if err := json.Unmarshal(body, &response); err != nil { + return nil, fmt.Errorf("failed to unmarshal ReversePrivateEndpoint: %w", err) + } + + return &response.Result, nil +} + +func (c *ClientImpl) DeleteReversePrivateEndpoint(ctx context.Context, serviceId, reversePrivateEndpointId string) error { + req, err := http.NewRequest(http.MethodDelete, c.GetReversePrivateEndpointPath(serviceId, reversePrivateEndpointId), nil) + if err != nil { + return err + } + + _, err = c.doRequest(ctx, req) + return err +} + +func (c *ClientImpl) WaitForReversePrivateEndpointState(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64) (rpe *ReversePrivateEndpoint, err error) { + checkState := func() error { + rpe, err = c.GetReversePrivateEndpoint(ctx, serviceId, reversePrivateEndpointId) + if err != nil { + return err + } + + if stateChecker(rpe.Status) { + return nil + } + + return fmt.Errorf("ClickPipe reverse private endpoint %s is in state %s", reversePrivateEndpointId, rpe.Status) + } + + if maxWaitSeconds < 5 { + maxWaitSeconds = 5 + } + + err = backoff.Retry(checkState, backoff.WithMaxRetries(backoff.NewConstantBackOff(5*time.Second), maxWaitSeconds/5)) + return +} diff --git a/pkg/internal/api/clickpipe_reverse_private_endpoint_models.go b/pkg/internal/api/clickpipe_reverse_private_endpoint_models.go new file mode 100644 index 00000000..a206eb86 --- /dev/null +++ b/pkg/internal/api/clickpipe_reverse_private_endpoint_models.go @@ -0,0 +1,24 @@ +package api + +// ReversePrivateEndpoint represents a ClickPipe reverse private endpoint +type ReversePrivateEndpoint struct { + CreateReversePrivateEndpoint + + ID string `json:"id,omitempty"` + ServiceID string `json:"serviceId,omitempty"` + EndpointID string `json:"endpointId,omitempty"` + DNSNames []string `json:"dnsNames,omitempty"` + PrivateDNSNames []string `json:"privateDnsNames,omitempty"` + Status string `json:"status,omitempty"` +} + +// CreateReversePrivateEndpoint is the request payload for creating a reverse private endpoint +type CreateReversePrivateEndpoint struct { + Description string `json:"description,omitempty"` + Type string `json:"type,omitempty"` + VPCEndpointServiceName *string `json:"vpcEndpointServiceName,omitempty"` + VPCResourceConfigurationID *string `json:"vpcResourceConfigurationId,omitempty"` + VPCResourceShareArn *string `json:"vpcResourceShareArn,omitempty"` + MSKClusterArn *string `json:"mskClusterArn,omitempty"` + MSKAuthentication *string `json:"mskAuthentication,omitempty"` +} diff --git a/pkg/internal/api/client_mock.go b/pkg/internal/api/client_mock.go index de336bac..2505e53c 100644 --- a/pkg/internal/api/client_mock.go +++ b/pkg/internal/api/client_mock.go @@ -1,4 +1,4 @@ -// Code generated by http://github.com/gojuno/minimock (v3.3.13). DO NOT EDIT. +// Code generated by http://github.com/gojuno/minimock (v3.4.3). DO NOT EDIT. package api @@ -19,234 +19,315 @@ type ClientMock struct { finishOnce sync.Once funcChangeClickPipeState func(ctx context.Context, serviceId string, clickPipeId string, command string) (cp1 *ClickPipe, err error) + funcChangeClickPipeStateOrigin string inspectFuncChangeClickPipeState func(ctx context.Context, serviceId string, clickPipeId string, command string) afterChangeClickPipeStateCounter uint64 beforeChangeClickPipeStateCounter uint64 ChangeClickPipeStateMock mClientMockChangeClickPipeState funcCreateClickPipe func(ctx context.Context, serviceId string, clickPipe ClickPipe) (cp1 *ClickPipe, err error) + funcCreateClickPipeOrigin string inspectFuncCreateClickPipe func(ctx context.Context, serviceId string, clickPipe ClickPipe) afterCreateClickPipeCounter uint64 beforeCreateClickPipeCounter uint64 CreateClickPipeMock mClientMockCreateClickPipe funcCreateDatabase func(ctx context.Context, serviceID string, db Database) (err error) + funcCreateDatabaseOrigin string inspectFuncCreateDatabase func(ctx context.Context, serviceID string, db Database) afterCreateDatabaseCounter uint64 beforeCreateDatabaseCounter uint64 CreateDatabaseMock mClientMockCreateDatabase funcCreateQueryEndpoint func(ctx context.Context, serviceID string, endpoint ServiceQueryEndpoint) (sp1 *ServiceQueryEndpoint, err error) + funcCreateQueryEndpointOrigin string inspectFuncCreateQueryEndpoint func(ctx context.Context, serviceID string, endpoint ServiceQueryEndpoint) afterCreateQueryEndpointCounter uint64 beforeCreateQueryEndpointCounter uint64 CreateQueryEndpointMock mClientMockCreateQueryEndpoint + funcCreateReversePrivateEndpoint func(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint) (rp1 *ReversePrivateEndpoint, err error) + funcCreateReversePrivateEndpointOrigin string + inspectFuncCreateReversePrivateEndpoint func(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint) + afterCreateReversePrivateEndpointCounter uint64 + beforeCreateReversePrivateEndpointCounter uint64 + CreateReversePrivateEndpointMock mClientMockCreateReversePrivateEndpoint + funcCreateRole func(ctx context.Context, serviceId string, role Role) (rp1 *Role, err error) + funcCreateRoleOrigin string inspectFuncCreateRole func(ctx context.Context, serviceId string, role Role) afterCreateRoleCounter uint64 beforeCreateRoleCounter uint64 CreateRoleMock mClientMockCreateRole funcCreateService func(ctx context.Context, s Service) (sp1 *Service, s1 string, err error) + funcCreateServiceOrigin string inspectFuncCreateService func(ctx context.Context, s Service) afterCreateServiceCounter uint64 beforeCreateServiceCounter uint64 CreateServiceMock mClientMockCreateService funcCreateUser func(ctx context.Context, serviceId string, user User) (up1 *User, err error) + funcCreateUserOrigin string inspectFuncCreateUser func(ctx context.Context, serviceId string, user User) afterCreateUserCounter uint64 beforeCreateUserCounter uint64 CreateUserMock mClientMockCreateUser funcDeleteClickPipe func(ctx context.Context, serviceId string, clickPipeId string) (err error) + funcDeleteClickPipeOrigin string inspectFuncDeleteClickPipe func(ctx context.Context, serviceId string, clickPipeId string) afterDeleteClickPipeCounter uint64 beforeDeleteClickPipeCounter uint64 DeleteClickPipeMock mClientMockDeleteClickPipe funcDeleteDatabase func(ctx context.Context, serviceID string, name string) (err error) + funcDeleteDatabaseOrigin string inspectFuncDeleteDatabase func(ctx context.Context, serviceID string, name string) afterDeleteDatabaseCounter uint64 beforeDeleteDatabaseCounter uint64 DeleteDatabaseMock mClientMockDeleteDatabase funcDeleteQueryEndpoint func(ctx context.Context, serviceID string) (err error) + funcDeleteQueryEndpointOrigin string inspectFuncDeleteQueryEndpoint func(ctx context.Context, serviceID string) afterDeleteQueryEndpointCounter uint64 beforeDeleteQueryEndpointCounter uint64 DeleteQueryEndpointMock mClientMockDeleteQueryEndpoint + funcDeleteReversePrivateEndpoint func(ctx context.Context, serviceId string, reversePrivateEndpointId string) (err error) + funcDeleteReversePrivateEndpointOrigin string + inspectFuncDeleteReversePrivateEndpoint func(ctx context.Context, serviceId string, reversePrivateEndpointId string) + afterDeleteReversePrivateEndpointCounter uint64 + beforeDeleteReversePrivateEndpointCounter uint64 + DeleteReversePrivateEndpointMock mClientMockDeleteReversePrivateEndpoint + funcDeleteRole func(ctx context.Context, serviceID string, name string) (err error) + funcDeleteRoleOrigin string inspectFuncDeleteRole func(ctx context.Context, serviceID string, name string) afterDeleteRoleCounter uint64 beforeDeleteRoleCounter uint64 DeleteRoleMock mClientMockDeleteRole funcDeleteService func(ctx context.Context, serviceId string) (sp1 *Service, err error) + funcDeleteServiceOrigin string inspectFuncDeleteService func(ctx context.Context, serviceId string) afterDeleteServiceCounter uint64 beforeDeleteServiceCounter uint64 DeleteServiceMock mClientMockDeleteService funcDeleteUser func(ctx context.Context, serviceID string, name string) (err error) + funcDeleteUserOrigin string inspectFuncDeleteUser func(ctx context.Context, serviceID string, name string) afterDeleteUserCounter uint64 beforeDeleteUserCounter uint64 DeleteUserMock mClientMockDeleteUser funcGetApiKeyID func(ctx context.Context, name *string) (ap1 *ApiKey, err error) + funcGetApiKeyIDOrigin string inspectFuncGetApiKeyID func(ctx context.Context, name *string) afterGetApiKeyIDCounter uint64 beforeGetApiKeyIDCounter uint64 GetApiKeyIDMock mClientMockGetApiKeyID funcGetBackupConfiguration func(ctx context.Context, serviceId string) (bp1 *BackupConfiguration, err error) + funcGetBackupConfigurationOrigin string inspectFuncGetBackupConfiguration func(ctx context.Context, serviceId string) afterGetBackupConfigurationCounter uint64 beforeGetBackupConfigurationCounter uint64 GetBackupConfigurationMock mClientMockGetBackupConfiguration funcGetClickPipe func(ctx context.Context, serviceId string, clickPipeId string) (cp1 *ClickPipe, err error) + funcGetClickPipeOrigin string inspectFuncGetClickPipe func(ctx context.Context, serviceId string, clickPipeId string) afterGetClickPipeCounter uint64 beforeGetClickPipeCounter uint64 GetClickPipeMock mClientMockGetClickPipe funcGetDatabase func(ctx context.Context, serviceID string, name string) (dp1 *Database, err error) + funcGetDatabaseOrigin string inspectFuncGetDatabase func(ctx context.Context, serviceID string, name string) afterGetDatabaseCounter uint64 beforeGetDatabaseCounter uint64 GetDatabaseMock mClientMockGetDatabase funcGetGrantPrivilege func(ctx context.Context, serviceID string, accessType string, database *string, table *string, column *string, granteeUserName *string, granteeRoleName *string) (gp1 *GrantPrivilege, err error) + funcGetGrantPrivilegeOrigin string inspectFuncGetGrantPrivilege func(ctx context.Context, serviceID string, accessType string, database *string, table *string, column *string, granteeUserName *string, granteeRoleName *string) afterGetGrantPrivilegeCounter uint64 beforeGetGrantPrivilegeCounter uint64 GetGrantPrivilegeMock mClientMockGetGrantPrivilege funcGetGrantRole func(ctx context.Context, serviceID string, grantedRoleName string, granteeUserName *string, granteeRoleName *string) (gp1 *GrantRole, err error) + funcGetGrantRoleOrigin string inspectFuncGetGrantRole func(ctx context.Context, serviceID string, grantedRoleName string, granteeUserName *string, granteeRoleName *string) afterGetGrantRoleCounter uint64 beforeGetGrantRoleCounter uint64 GetGrantRoleMock mClientMockGetGrantRole funcGetOrgPrivateEndpointConfig func(ctx context.Context, cloudProvider string, region string) (op1 *OrgPrivateEndpointConfig, err error) + funcGetOrgPrivateEndpointConfigOrigin string inspectFuncGetOrgPrivateEndpointConfig func(ctx context.Context, cloudProvider string, region string) afterGetOrgPrivateEndpointConfigCounter uint64 beforeGetOrgPrivateEndpointConfigCounter uint64 GetOrgPrivateEndpointConfigMock mClientMockGetOrgPrivateEndpointConfig funcGetOrganizationPrivateEndpoints func(ctx context.Context) (pap1 *[]PrivateEndpoint, err error) + funcGetOrganizationPrivateEndpointsOrigin string inspectFuncGetOrganizationPrivateEndpoints func(ctx context.Context) afterGetOrganizationPrivateEndpointsCounter uint64 beforeGetOrganizationPrivateEndpointsCounter uint64 GetOrganizationPrivateEndpointsMock mClientMockGetOrganizationPrivateEndpoints funcGetQueryEndpoint func(ctx context.Context, serviceID string) (sp1 *ServiceQueryEndpoint, err error) + funcGetQueryEndpointOrigin string inspectFuncGetQueryEndpoint func(ctx context.Context, serviceID string) afterGetQueryEndpointCounter uint64 beforeGetQueryEndpointCounter uint64 GetQueryEndpointMock mClientMockGetQueryEndpoint + funcGetReversePrivateEndpoint func(ctx context.Context, serviceId string, reversePrivateEndpointId string) (rp1 *ReversePrivateEndpoint, err error) + funcGetReversePrivateEndpointOrigin string + inspectFuncGetReversePrivateEndpoint func(ctx context.Context, serviceId string, reversePrivateEndpointId string) + afterGetReversePrivateEndpointCounter uint64 + beforeGetReversePrivateEndpointCounter uint64 + GetReversePrivateEndpointMock mClientMockGetReversePrivateEndpoint + + funcGetReversePrivateEndpointPath func(serviceId string, reversePrivateEndpointId string) (s1 string) + funcGetReversePrivateEndpointPathOrigin string + inspectFuncGetReversePrivateEndpointPath func(serviceId string, reversePrivateEndpointId string) + afterGetReversePrivateEndpointPathCounter uint64 + beforeGetReversePrivateEndpointPathCounter uint64 + GetReversePrivateEndpointPathMock mClientMockGetReversePrivateEndpointPath + funcGetRole func(ctx context.Context, serviceID string, name string) (rp1 *Role, err error) + funcGetRoleOrigin string inspectFuncGetRole func(ctx context.Context, serviceID string, name string) afterGetRoleCounter uint64 beforeGetRoleCounter uint64 GetRoleMock mClientMockGetRole funcGetService func(ctx context.Context, serviceId string) (sp1 *Service, err error) + funcGetServiceOrigin string inspectFuncGetService func(ctx context.Context, serviceId string) afterGetServiceCounter uint64 beforeGetServiceCounter uint64 GetServiceMock mClientMockGetService funcGetUser func(ctx context.Context, serviceID string, name string) (up1 *User, err error) + funcGetUserOrigin string inspectFuncGetUser func(ctx context.Context, serviceID string, name string) afterGetUserCounter uint64 beforeGetUserCounter uint64 GetUserMock mClientMockGetUser funcGrantPrivilege func(ctx context.Context, serviceId string, grantPrivilege GrantPrivilege) (gp1 *GrantPrivilege, err error) + funcGrantPrivilegeOrigin string inspectFuncGrantPrivilege func(ctx context.Context, serviceId string, grantPrivilege GrantPrivilege) afterGrantPrivilegeCounter uint64 beforeGrantPrivilegeCounter uint64 GrantPrivilegeMock mClientMockGrantPrivilege funcGrantRole func(ctx context.Context, serviceId string, grantRole GrantRole) (gp1 *GrantRole, err error) + funcGrantRoleOrigin string inspectFuncGrantRole func(ctx context.Context, serviceId string, grantRole GrantRole) afterGrantRoleCounter uint64 beforeGrantRoleCounter uint64 GrantRoleMock mClientMockGrantRole + funcListReversePrivateEndpoints func(ctx context.Context, serviceId string) (rpa1 []*ReversePrivateEndpoint, err error) + funcListReversePrivateEndpointsOrigin string + inspectFuncListReversePrivateEndpoints func(ctx context.Context, serviceId string) + afterListReversePrivateEndpointsCounter uint64 + beforeListReversePrivateEndpointsCounter uint64 + ListReversePrivateEndpointsMock mClientMockListReversePrivateEndpoints + funcRevokeGrantPrivilege func(ctx context.Context, serviceID string, accessType string, database *string, table *string, column *string, granteeUserName *string, granteeRoleName *string) (err error) + funcRevokeGrantPrivilegeOrigin string inspectFuncRevokeGrantPrivilege func(ctx context.Context, serviceID string, accessType string, database *string, table *string, column *string, granteeUserName *string, granteeRoleName *string) afterRevokeGrantPrivilegeCounter uint64 beforeRevokeGrantPrivilegeCounter uint64 RevokeGrantPrivilegeMock mClientMockRevokeGrantPrivilege funcRevokeGrantRole func(ctx context.Context, serviceID string, grantedRoleName string, granteeUserName *string, granteeRoleName *string) (err error) + funcRevokeGrantRoleOrigin string inspectFuncRevokeGrantRole func(ctx context.Context, serviceID string, grantedRoleName string, granteeUserName *string, granteeRoleName *string) afterRevokeGrantRoleCounter uint64 beforeRevokeGrantRoleCounter uint64 RevokeGrantRoleMock mClientMockRevokeGrantRole funcScalingClickPipe func(ctx context.Context, serviceId string, clickPipeId string, request ClickPipeScaling) (cp1 *ClickPipe, err error) + funcScalingClickPipeOrigin string inspectFuncScalingClickPipe func(ctx context.Context, serviceId string, clickPipeId string, request ClickPipeScaling) afterScalingClickPipeCounter uint64 beforeScalingClickPipeCounter uint64 ScalingClickPipeMock mClientMockScalingClickPipe funcSyncDatabase func(ctx context.Context, serviceID string, db Database) (err error) + funcSyncDatabaseOrigin string inspectFuncSyncDatabase func(ctx context.Context, serviceID string, db Database) afterSyncDatabaseCounter uint64 beforeSyncDatabaseCounter uint64 SyncDatabaseMock mClientMockSyncDatabase funcUpdateBackupConfiguration func(ctx context.Context, serviceId string, b BackupConfiguration) (bp1 *BackupConfiguration, err error) + funcUpdateBackupConfigurationOrigin string inspectFuncUpdateBackupConfiguration func(ctx context.Context, serviceId string, b BackupConfiguration) afterUpdateBackupConfigurationCounter uint64 beforeUpdateBackupConfigurationCounter uint64 UpdateBackupConfigurationMock mClientMockUpdateBackupConfiguration funcUpdateClickPipe func(ctx context.Context, serviceId string, clickPipeId string, request ClickPipeUpdate) (cp1 *ClickPipe, err error) + funcUpdateClickPipeOrigin string inspectFuncUpdateClickPipe func(ctx context.Context, serviceId string, clickPipeId string, request ClickPipeUpdate) afterUpdateClickPipeCounter uint64 beforeUpdateClickPipeCounter uint64 UpdateClickPipeMock mClientMockUpdateClickPipe funcUpdateOrganizationPrivateEndpoints func(ctx context.Context, orgUpdate OrganizationUpdate) (pap1 *[]PrivateEndpoint, err error) + funcUpdateOrganizationPrivateEndpointsOrigin string inspectFuncUpdateOrganizationPrivateEndpoints func(ctx context.Context, orgUpdate OrganizationUpdate) afterUpdateOrganizationPrivateEndpointsCounter uint64 beforeUpdateOrganizationPrivateEndpointsCounter uint64 UpdateOrganizationPrivateEndpointsMock mClientMockUpdateOrganizationPrivateEndpoints funcUpdateReplicaScaling func(ctx context.Context, serviceId string, s ReplicaScalingUpdate) (sp1 *Service, err error) + funcUpdateReplicaScalingOrigin string inspectFuncUpdateReplicaScaling func(ctx context.Context, serviceId string, s ReplicaScalingUpdate) afterUpdateReplicaScalingCounter uint64 beforeUpdateReplicaScalingCounter uint64 UpdateReplicaScalingMock mClientMockUpdateReplicaScaling funcUpdateService func(ctx context.Context, serviceId string, s ServiceUpdate) (sp1 *Service, err error) + funcUpdateServiceOrigin string inspectFuncUpdateService func(ctx context.Context, serviceId string, s ServiceUpdate) afterUpdateServiceCounter uint64 beforeUpdateServiceCounter uint64 UpdateServiceMock mClientMockUpdateService funcUpdateServicePassword func(ctx context.Context, serviceId string, u ServicePasswordUpdate) (sp1 *ServicePasswordUpdateResult, err error) + funcUpdateServicePasswordOrigin string inspectFuncUpdateServicePassword func(ctx context.Context, serviceId string, u ServicePasswordUpdate) afterUpdateServicePasswordCounter uint64 beforeUpdateServicePasswordCounter uint64 UpdateServicePasswordMock mClientMockUpdateServicePassword funcWaitForClickPipeState func(ctx context.Context, serviceId string, clickPipeId string, stateChecker func(string) bool, maxWaitSeconds uint64) (cp1 *ClickPipe, err error) + funcWaitForClickPipeStateOrigin string inspectFuncWaitForClickPipeState func(ctx context.Context, serviceId string, clickPipeId string, stateChecker func(string) bool, maxWaitSeconds uint64) afterWaitForClickPipeStateCounter uint64 beforeWaitForClickPipeStateCounter uint64 WaitForClickPipeStateMock mClientMockWaitForClickPipeState + funcWaitForReversePrivateEndpointState func(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64) (rp1 *ReversePrivateEndpoint, err error) + funcWaitForReversePrivateEndpointStateOrigin string + inspectFuncWaitForReversePrivateEndpointState func(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64) + afterWaitForReversePrivateEndpointStateCounter uint64 + beforeWaitForReversePrivateEndpointStateCounter uint64 + WaitForReversePrivateEndpointStateMock mClientMockWaitForReversePrivateEndpointState + funcWaitForServiceState func(ctx context.Context, serviceId string, stateChecker func(string) bool, maxWaitSeconds int) (err error) + funcWaitForServiceStateOrigin string inspectFuncWaitForServiceState func(ctx context.Context, serviceId string, stateChecker func(string) bool, maxWaitSeconds int) afterWaitForServiceStateCounter uint64 beforeWaitForServiceStateCounter uint64 @@ -273,6 +354,9 @@ func NewClientMock(t minimock.Tester) *ClientMock { m.CreateQueryEndpointMock = mClientMockCreateQueryEndpoint{mock: m} m.CreateQueryEndpointMock.callArgs = []*ClientMockCreateQueryEndpointParams{} + m.CreateReversePrivateEndpointMock = mClientMockCreateReversePrivateEndpoint{mock: m} + m.CreateReversePrivateEndpointMock.callArgs = []*ClientMockCreateReversePrivateEndpointParams{} + m.CreateRoleMock = mClientMockCreateRole{mock: m} m.CreateRoleMock.callArgs = []*ClientMockCreateRoleParams{} @@ -291,6 +375,9 @@ func NewClientMock(t minimock.Tester) *ClientMock { m.DeleteQueryEndpointMock = mClientMockDeleteQueryEndpoint{mock: m} m.DeleteQueryEndpointMock.callArgs = []*ClientMockDeleteQueryEndpointParams{} + m.DeleteReversePrivateEndpointMock = mClientMockDeleteReversePrivateEndpoint{mock: m} + m.DeleteReversePrivateEndpointMock.callArgs = []*ClientMockDeleteReversePrivateEndpointParams{} + m.DeleteRoleMock = mClientMockDeleteRole{mock: m} m.DeleteRoleMock.callArgs = []*ClientMockDeleteRoleParams{} @@ -327,6 +414,12 @@ func NewClientMock(t minimock.Tester) *ClientMock { m.GetQueryEndpointMock = mClientMockGetQueryEndpoint{mock: m} m.GetQueryEndpointMock.callArgs = []*ClientMockGetQueryEndpointParams{} + m.GetReversePrivateEndpointMock = mClientMockGetReversePrivateEndpoint{mock: m} + m.GetReversePrivateEndpointMock.callArgs = []*ClientMockGetReversePrivateEndpointParams{} + + m.GetReversePrivateEndpointPathMock = mClientMockGetReversePrivateEndpointPath{mock: m} + m.GetReversePrivateEndpointPathMock.callArgs = []*ClientMockGetReversePrivateEndpointPathParams{} + m.GetRoleMock = mClientMockGetRole{mock: m} m.GetRoleMock.callArgs = []*ClientMockGetRoleParams{} @@ -342,6 +435,9 @@ func NewClientMock(t minimock.Tester) *ClientMock { m.GrantRoleMock = mClientMockGrantRole{mock: m} m.GrantRoleMock.callArgs = []*ClientMockGrantRoleParams{} + m.ListReversePrivateEndpointsMock = mClientMockListReversePrivateEndpoints{mock: m} + m.ListReversePrivateEndpointsMock.callArgs = []*ClientMockListReversePrivateEndpointsParams{} + m.RevokeGrantPrivilegeMock = mClientMockRevokeGrantPrivilege{mock: m} m.RevokeGrantPrivilegeMock.callArgs = []*ClientMockRevokeGrantPrivilegeParams{} @@ -375,6 +471,9 @@ func NewClientMock(t minimock.Tester) *ClientMock { m.WaitForClickPipeStateMock = mClientMockWaitForClickPipeState{mock: m} m.WaitForClickPipeStateMock.callArgs = []*ClientMockWaitForClickPipeStateParams{} + m.WaitForReversePrivateEndpointStateMock = mClientMockWaitForReversePrivateEndpointState{mock: m} + m.WaitForReversePrivateEndpointStateMock.callArgs = []*ClientMockWaitForReversePrivateEndpointStateParams{} + m.WaitForServiceStateMock = mClientMockWaitForServiceState{mock: m} m.WaitForServiceStateMock.callArgs = []*ClientMockWaitForServiceStateParams{} @@ -392,16 +491,19 @@ type mClientMockChangeClickPipeState struct { callArgs []*ClientMockChangeClickPipeStateParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockChangeClickPipeStateExpectation specifies expectation struct of the Client.ChangeClickPipeState type ClientMockChangeClickPipeStateExpectation struct { - mock *ClientMock - params *ClientMockChangeClickPipeStateParams - paramPtrs *ClientMockChangeClickPipeStateParamPtrs - results *ClientMockChangeClickPipeStateResults - Counter uint64 + mock *ClientMock + params *ClientMockChangeClickPipeStateParams + paramPtrs *ClientMockChangeClickPipeStateParamPtrs + expectationOrigins ClientMockChangeClickPipeStateExpectationOrigins + results *ClientMockChangeClickPipeStateResults + returnOrigin string + Counter uint64 } // ClientMockChangeClickPipeStateParams contains parameters of the Client.ChangeClickPipeState @@ -426,6 +528,15 @@ type ClientMockChangeClickPipeStateResults struct { err error } +// ClientMockChangeClickPipeStateOrigins contains origins of expectations of the Client.ChangeClickPipeState +type ClientMockChangeClickPipeStateExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originClickPipeId string + originCommand string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -451,6 +562,7 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) Expect(ctx contex } mmChangeClickPipeState.defaultExpectation.params = &ClientMockChangeClickPipeStateParams{ctx, serviceId, clickPipeId, command} + mmChangeClickPipeState.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmChangeClickPipeState.expectations { if minimock.Equal(e.params, mmChangeClickPipeState.defaultExpectation.params) { mmChangeClickPipeState.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmChangeClickPipeState.defaultExpectation.params) @@ -478,6 +590,7 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) ExpectCtxParam1(c mmChangeClickPipeState.defaultExpectation.paramPtrs = &ClientMockChangeClickPipeStateParamPtrs{} } mmChangeClickPipeState.defaultExpectation.paramPtrs.ctx = &ctx + mmChangeClickPipeState.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmChangeClickPipeState } @@ -500,6 +613,7 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) ExpectServiceIdPa mmChangeClickPipeState.defaultExpectation.paramPtrs = &ClientMockChangeClickPipeStateParamPtrs{} } mmChangeClickPipeState.defaultExpectation.paramPtrs.serviceId = &serviceId + mmChangeClickPipeState.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmChangeClickPipeState } @@ -522,6 +636,7 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) ExpectClickPipeId mmChangeClickPipeState.defaultExpectation.paramPtrs = &ClientMockChangeClickPipeStateParamPtrs{} } mmChangeClickPipeState.defaultExpectation.paramPtrs.clickPipeId = &clickPipeId + mmChangeClickPipeState.defaultExpectation.expectationOrigins.originClickPipeId = minimock.CallerInfo(1) return mmChangeClickPipeState } @@ -544,6 +659,7 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) ExpectCommandPara mmChangeClickPipeState.defaultExpectation.paramPtrs = &ClientMockChangeClickPipeStateParamPtrs{} } mmChangeClickPipeState.defaultExpectation.paramPtrs.command = &command + mmChangeClickPipeState.defaultExpectation.expectationOrigins.originCommand = minimock.CallerInfo(1) return mmChangeClickPipeState } @@ -569,6 +685,7 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) Return(cp1 *Click mmChangeClickPipeState.defaultExpectation = &ClientMockChangeClickPipeStateExpectation{mock: mmChangeClickPipeState.mock} } mmChangeClickPipeState.defaultExpectation.results = &ClientMockChangeClickPipeStateResults{cp1, err} + mmChangeClickPipeState.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmChangeClickPipeState.mock } @@ -583,6 +700,7 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) Set(f func(ctx co } mmChangeClickPipeState.mock.funcChangeClickPipeState = f + mmChangeClickPipeState.mock.funcChangeClickPipeStateOrigin = minimock.CallerInfo(1) return mmChangeClickPipeState.mock } @@ -594,8 +712,9 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) When(ctx context. } expectation := &ClientMockChangeClickPipeStateExpectation{ - mock: mmChangeClickPipeState.mock, - params: &ClientMockChangeClickPipeStateParams{ctx, serviceId, clickPipeId, command}, + mock: mmChangeClickPipeState.mock, + params: &ClientMockChangeClickPipeStateParams{ctx, serviceId, clickPipeId, command}, + expectationOrigins: ClientMockChangeClickPipeStateExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmChangeClickPipeState.expectations = append(mmChangeClickPipeState.expectations, expectation) return expectation @@ -613,6 +732,7 @@ func (mmChangeClickPipeState *mClientMockChangeClickPipeState) Times(n uint64) * mmChangeClickPipeState.mock.t.Fatalf("Times of ClientMock.ChangeClickPipeState mock can not be zero") } mm_atomic.StoreUint64(&mmChangeClickPipeState.expectedInvocations, n) + mmChangeClickPipeState.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmChangeClickPipeState } @@ -632,6 +752,8 @@ func (mmChangeClickPipeState *ClientMock) ChangeClickPipeState(ctx context.Conte mm_atomic.AddUint64(&mmChangeClickPipeState.beforeChangeClickPipeStateCounter, 1) defer mm_atomic.AddUint64(&mmChangeClickPipeState.afterChangeClickPipeStateCounter, 1) + mmChangeClickPipeState.t.Helper() + if mmChangeClickPipeState.inspectFuncChangeClickPipeState != nil { mmChangeClickPipeState.inspectFuncChangeClickPipeState(ctx, serviceId, clickPipeId, command) } @@ -660,23 +782,28 @@ func (mmChangeClickPipeState *ClientMock) ChangeClickPipeState(ctx context.Conte if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmChangeClickPipeState.ChangeClickPipeStateMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmChangeClickPipeState.ChangeClickPipeStateMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.clickPipeId != nil && !minimock.Equal(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId) { - mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameter clickPipeId, want: %#v, got: %#v%s\n", *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) + mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameter clickPipeId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmChangeClickPipeState.ChangeClickPipeStateMock.defaultExpectation.expectationOrigins.originClickPipeId, *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) } if mm_want_ptrs.command != nil && !minimock.Equal(*mm_want_ptrs.command, mm_got.command) { - mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameter command, want: %#v, got: %#v%s\n", *mm_want_ptrs.command, mm_got.command, minimock.Diff(*mm_want_ptrs.command, mm_got.command)) + mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameter command, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmChangeClickPipeState.ChangeClickPipeStateMock.defaultExpectation.expectationOrigins.originCommand, *mm_want_ptrs.command, mm_got.command, minimock.Diff(*mm_want_ptrs.command, mm_got.command)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmChangeClickPipeState.t.Errorf("ClientMock.ChangeClickPipeState got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmChangeClickPipeState.ChangeClickPipeStateMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmChangeClickPipeState.ChangeClickPipeStateMock.defaultExpectation.results @@ -736,7 +863,7 @@ func (m *ClientMock) MinimockChangeClickPipeStateDone() bool { func (m *ClientMock) MinimockChangeClickPipeStateInspect() { for _, e := range m.ChangeClickPipeStateMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.ChangeClickPipeState with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.ChangeClickPipeState at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -744,19 +871,19 @@ func (m *ClientMock) MinimockChangeClickPipeStateInspect() { // if default expectation was set then invocations count should be greater than zero if m.ChangeClickPipeStateMock.defaultExpectation != nil && afterChangeClickPipeStateCounter < 1 { if m.ChangeClickPipeStateMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.ChangeClickPipeState") + m.t.Errorf("Expected call to ClientMock.ChangeClickPipeState at\n%s", m.ChangeClickPipeStateMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.ChangeClickPipeState with params: %#v", *m.ChangeClickPipeStateMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.ChangeClickPipeState at\n%s with params: %#v", m.ChangeClickPipeStateMock.defaultExpectation.expectationOrigins.origin, *m.ChangeClickPipeStateMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcChangeClickPipeState != nil && afterChangeClickPipeStateCounter < 1 { - m.t.Error("Expected call to ClientMock.ChangeClickPipeState") + m.t.Errorf("Expected call to ClientMock.ChangeClickPipeState at\n%s", m.funcChangeClickPipeStateOrigin) } if !m.ChangeClickPipeStateMock.invocationsDone() && afterChangeClickPipeStateCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.ChangeClickPipeState but found %d calls", - mm_atomic.LoadUint64(&m.ChangeClickPipeStateMock.expectedInvocations), afterChangeClickPipeStateCounter) + m.t.Errorf("Expected %d calls to ClientMock.ChangeClickPipeState at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ChangeClickPipeStateMock.expectedInvocations), m.ChangeClickPipeStateMock.expectedInvocationsOrigin, afterChangeClickPipeStateCounter) } } @@ -769,16 +896,19 @@ type mClientMockCreateClickPipe struct { callArgs []*ClientMockCreateClickPipeParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockCreateClickPipeExpectation specifies expectation struct of the Client.CreateClickPipe type ClientMockCreateClickPipeExpectation struct { - mock *ClientMock - params *ClientMockCreateClickPipeParams - paramPtrs *ClientMockCreateClickPipeParamPtrs - results *ClientMockCreateClickPipeResults - Counter uint64 + mock *ClientMock + params *ClientMockCreateClickPipeParams + paramPtrs *ClientMockCreateClickPipeParamPtrs + expectationOrigins ClientMockCreateClickPipeExpectationOrigins + results *ClientMockCreateClickPipeResults + returnOrigin string + Counter uint64 } // ClientMockCreateClickPipeParams contains parameters of the Client.CreateClickPipe @@ -801,6 +931,14 @@ type ClientMockCreateClickPipeResults struct { err error } +// ClientMockCreateClickPipeOrigins contains origins of expectations of the Client.CreateClickPipe +type ClientMockCreateClickPipeExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originClickPipe string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -826,6 +964,7 @@ func (mmCreateClickPipe *mClientMockCreateClickPipe) Expect(ctx context.Context, } mmCreateClickPipe.defaultExpectation.params = &ClientMockCreateClickPipeParams{ctx, serviceId, clickPipe} + mmCreateClickPipe.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmCreateClickPipe.expectations { if minimock.Equal(e.params, mmCreateClickPipe.defaultExpectation.params) { mmCreateClickPipe.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateClickPipe.defaultExpectation.params) @@ -853,6 +992,7 @@ func (mmCreateClickPipe *mClientMockCreateClickPipe) ExpectCtxParam1(ctx context mmCreateClickPipe.defaultExpectation.paramPtrs = &ClientMockCreateClickPipeParamPtrs{} } mmCreateClickPipe.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateClickPipe.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmCreateClickPipe } @@ -875,6 +1015,7 @@ func (mmCreateClickPipe *mClientMockCreateClickPipe) ExpectServiceIdParam2(servi mmCreateClickPipe.defaultExpectation.paramPtrs = &ClientMockCreateClickPipeParamPtrs{} } mmCreateClickPipe.defaultExpectation.paramPtrs.serviceId = &serviceId + mmCreateClickPipe.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmCreateClickPipe } @@ -897,6 +1038,7 @@ func (mmCreateClickPipe *mClientMockCreateClickPipe) ExpectClickPipeParam3(click mmCreateClickPipe.defaultExpectation.paramPtrs = &ClientMockCreateClickPipeParamPtrs{} } mmCreateClickPipe.defaultExpectation.paramPtrs.clickPipe = &clickPipe + mmCreateClickPipe.defaultExpectation.expectationOrigins.originClickPipe = minimock.CallerInfo(1) return mmCreateClickPipe } @@ -922,6 +1064,7 @@ func (mmCreateClickPipe *mClientMockCreateClickPipe) Return(cp1 *ClickPipe, err mmCreateClickPipe.defaultExpectation = &ClientMockCreateClickPipeExpectation{mock: mmCreateClickPipe.mock} } mmCreateClickPipe.defaultExpectation.results = &ClientMockCreateClickPipeResults{cp1, err} + mmCreateClickPipe.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmCreateClickPipe.mock } @@ -936,6 +1079,7 @@ func (mmCreateClickPipe *mClientMockCreateClickPipe) Set(f func(ctx context.Cont } mmCreateClickPipe.mock.funcCreateClickPipe = f + mmCreateClickPipe.mock.funcCreateClickPipeOrigin = minimock.CallerInfo(1) return mmCreateClickPipe.mock } @@ -947,8 +1091,9 @@ func (mmCreateClickPipe *mClientMockCreateClickPipe) When(ctx context.Context, s } expectation := &ClientMockCreateClickPipeExpectation{ - mock: mmCreateClickPipe.mock, - params: &ClientMockCreateClickPipeParams{ctx, serviceId, clickPipe}, + mock: mmCreateClickPipe.mock, + params: &ClientMockCreateClickPipeParams{ctx, serviceId, clickPipe}, + expectationOrigins: ClientMockCreateClickPipeExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmCreateClickPipe.expectations = append(mmCreateClickPipe.expectations, expectation) return expectation @@ -966,6 +1111,7 @@ func (mmCreateClickPipe *mClientMockCreateClickPipe) Times(n uint64) *mClientMoc mmCreateClickPipe.mock.t.Fatalf("Times of ClientMock.CreateClickPipe mock can not be zero") } mm_atomic.StoreUint64(&mmCreateClickPipe.expectedInvocations, n) + mmCreateClickPipe.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmCreateClickPipe } @@ -985,6 +1131,8 @@ func (mmCreateClickPipe *ClientMock) CreateClickPipe(ctx context.Context, servic mm_atomic.AddUint64(&mmCreateClickPipe.beforeCreateClickPipeCounter, 1) defer mm_atomic.AddUint64(&mmCreateClickPipe.afterCreateClickPipeCounter, 1) + mmCreateClickPipe.t.Helper() + if mmCreateClickPipe.inspectFuncCreateClickPipe != nil { mmCreateClickPipe.inspectFuncCreateClickPipe(ctx, serviceId, clickPipe) } @@ -1013,19 +1161,23 @@ func (mmCreateClickPipe *ClientMock) CreateClickPipe(ctx context.Context, servic if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateClickPipe.t.Errorf("ClientMock.CreateClickPipe got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateClickPipe.t.Errorf("ClientMock.CreateClickPipe got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateClickPipe.CreateClickPipeMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmCreateClickPipe.t.Errorf("ClientMock.CreateClickPipe got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmCreateClickPipe.t.Errorf("ClientMock.CreateClickPipe got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateClickPipe.CreateClickPipeMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.clickPipe != nil && !minimock.Equal(*mm_want_ptrs.clickPipe, mm_got.clickPipe) { - mmCreateClickPipe.t.Errorf("ClientMock.CreateClickPipe got unexpected parameter clickPipe, want: %#v, got: %#v%s\n", *mm_want_ptrs.clickPipe, mm_got.clickPipe, minimock.Diff(*mm_want_ptrs.clickPipe, mm_got.clickPipe)) + mmCreateClickPipe.t.Errorf("ClientMock.CreateClickPipe got unexpected parameter clickPipe, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateClickPipe.CreateClickPipeMock.defaultExpectation.expectationOrigins.originClickPipe, *mm_want_ptrs.clickPipe, mm_got.clickPipe, minimock.Diff(*mm_want_ptrs.clickPipe, mm_got.clickPipe)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateClickPipe.t.Errorf("ClientMock.CreateClickPipe got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateClickPipe.t.Errorf("ClientMock.CreateClickPipe got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateClickPipe.CreateClickPipeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmCreateClickPipe.CreateClickPipeMock.defaultExpectation.results @@ -1085,7 +1237,7 @@ func (m *ClientMock) MinimockCreateClickPipeDone() bool { func (m *ClientMock) MinimockCreateClickPipeInspect() { for _, e := range m.CreateClickPipeMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.CreateClickPipe with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.CreateClickPipe at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -1093,19 +1245,19 @@ func (m *ClientMock) MinimockCreateClickPipeInspect() { // if default expectation was set then invocations count should be greater than zero if m.CreateClickPipeMock.defaultExpectation != nil && afterCreateClickPipeCounter < 1 { if m.CreateClickPipeMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.CreateClickPipe") + m.t.Errorf("Expected call to ClientMock.CreateClickPipe at\n%s", m.CreateClickPipeMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.CreateClickPipe with params: %#v", *m.CreateClickPipeMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.CreateClickPipe at\n%s with params: %#v", m.CreateClickPipeMock.defaultExpectation.expectationOrigins.origin, *m.CreateClickPipeMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcCreateClickPipe != nil && afterCreateClickPipeCounter < 1 { - m.t.Error("Expected call to ClientMock.CreateClickPipe") + m.t.Errorf("Expected call to ClientMock.CreateClickPipe at\n%s", m.funcCreateClickPipeOrigin) } if !m.CreateClickPipeMock.invocationsDone() && afterCreateClickPipeCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.CreateClickPipe but found %d calls", - mm_atomic.LoadUint64(&m.CreateClickPipeMock.expectedInvocations), afterCreateClickPipeCounter) + m.t.Errorf("Expected %d calls to ClientMock.CreateClickPipe at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateClickPipeMock.expectedInvocations), m.CreateClickPipeMock.expectedInvocationsOrigin, afterCreateClickPipeCounter) } } @@ -1118,16 +1270,19 @@ type mClientMockCreateDatabase struct { callArgs []*ClientMockCreateDatabaseParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockCreateDatabaseExpectation specifies expectation struct of the Client.CreateDatabase type ClientMockCreateDatabaseExpectation struct { - mock *ClientMock - params *ClientMockCreateDatabaseParams - paramPtrs *ClientMockCreateDatabaseParamPtrs - results *ClientMockCreateDatabaseResults - Counter uint64 + mock *ClientMock + params *ClientMockCreateDatabaseParams + paramPtrs *ClientMockCreateDatabaseParamPtrs + expectationOrigins ClientMockCreateDatabaseExpectationOrigins + results *ClientMockCreateDatabaseResults + returnOrigin string + Counter uint64 } // ClientMockCreateDatabaseParams contains parameters of the Client.CreateDatabase @@ -1149,6 +1304,14 @@ type ClientMockCreateDatabaseResults struct { err error } +// ClientMockCreateDatabaseOrigins contains origins of expectations of the Client.CreateDatabase +type ClientMockCreateDatabaseExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originDb string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -1174,6 +1337,7 @@ func (mmCreateDatabase *mClientMockCreateDatabase) Expect(ctx context.Context, s } mmCreateDatabase.defaultExpectation.params = &ClientMockCreateDatabaseParams{ctx, serviceID, db} + mmCreateDatabase.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmCreateDatabase.expectations { if minimock.Equal(e.params, mmCreateDatabase.defaultExpectation.params) { mmCreateDatabase.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateDatabase.defaultExpectation.params) @@ -1201,6 +1365,7 @@ func (mmCreateDatabase *mClientMockCreateDatabase) ExpectCtxParam1(ctx context.C mmCreateDatabase.defaultExpectation.paramPtrs = &ClientMockCreateDatabaseParamPtrs{} } mmCreateDatabase.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateDatabase.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmCreateDatabase } @@ -1223,6 +1388,7 @@ func (mmCreateDatabase *mClientMockCreateDatabase) ExpectServiceIDParam2(service mmCreateDatabase.defaultExpectation.paramPtrs = &ClientMockCreateDatabaseParamPtrs{} } mmCreateDatabase.defaultExpectation.paramPtrs.serviceID = &serviceID + mmCreateDatabase.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmCreateDatabase } @@ -1245,6 +1411,7 @@ func (mmCreateDatabase *mClientMockCreateDatabase) ExpectDbParam3(db Database) * mmCreateDatabase.defaultExpectation.paramPtrs = &ClientMockCreateDatabaseParamPtrs{} } mmCreateDatabase.defaultExpectation.paramPtrs.db = &db + mmCreateDatabase.defaultExpectation.expectationOrigins.originDb = minimock.CallerInfo(1) return mmCreateDatabase } @@ -1270,6 +1437,7 @@ func (mmCreateDatabase *mClientMockCreateDatabase) Return(err error) *ClientMock mmCreateDatabase.defaultExpectation = &ClientMockCreateDatabaseExpectation{mock: mmCreateDatabase.mock} } mmCreateDatabase.defaultExpectation.results = &ClientMockCreateDatabaseResults{err} + mmCreateDatabase.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmCreateDatabase.mock } @@ -1284,6 +1452,7 @@ func (mmCreateDatabase *mClientMockCreateDatabase) Set(f func(ctx context.Contex } mmCreateDatabase.mock.funcCreateDatabase = f + mmCreateDatabase.mock.funcCreateDatabaseOrigin = minimock.CallerInfo(1) return mmCreateDatabase.mock } @@ -1295,8 +1464,9 @@ func (mmCreateDatabase *mClientMockCreateDatabase) When(ctx context.Context, ser } expectation := &ClientMockCreateDatabaseExpectation{ - mock: mmCreateDatabase.mock, - params: &ClientMockCreateDatabaseParams{ctx, serviceID, db}, + mock: mmCreateDatabase.mock, + params: &ClientMockCreateDatabaseParams{ctx, serviceID, db}, + expectationOrigins: ClientMockCreateDatabaseExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmCreateDatabase.expectations = append(mmCreateDatabase.expectations, expectation) return expectation @@ -1314,6 +1484,7 @@ func (mmCreateDatabase *mClientMockCreateDatabase) Times(n uint64) *mClientMockC mmCreateDatabase.mock.t.Fatalf("Times of ClientMock.CreateDatabase mock can not be zero") } mm_atomic.StoreUint64(&mmCreateDatabase.expectedInvocations, n) + mmCreateDatabase.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmCreateDatabase } @@ -1333,6 +1504,8 @@ func (mmCreateDatabase *ClientMock) CreateDatabase(ctx context.Context, serviceI mm_atomic.AddUint64(&mmCreateDatabase.beforeCreateDatabaseCounter, 1) defer mm_atomic.AddUint64(&mmCreateDatabase.afterCreateDatabaseCounter, 1) + mmCreateDatabase.t.Helper() + if mmCreateDatabase.inspectFuncCreateDatabase != nil { mmCreateDatabase.inspectFuncCreateDatabase(ctx, serviceID, db) } @@ -1361,19 +1534,23 @@ func (mmCreateDatabase *ClientMock) CreateDatabase(ctx context.Context, serviceI if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateDatabase.t.Errorf("ClientMock.CreateDatabase got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateDatabase.t.Errorf("ClientMock.CreateDatabase got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateDatabase.CreateDatabaseMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmCreateDatabase.t.Errorf("ClientMock.CreateDatabase got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmCreateDatabase.t.Errorf("ClientMock.CreateDatabase got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateDatabase.CreateDatabaseMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.db != nil && !minimock.Equal(*mm_want_ptrs.db, mm_got.db) { - mmCreateDatabase.t.Errorf("ClientMock.CreateDatabase got unexpected parameter db, want: %#v, got: %#v%s\n", *mm_want_ptrs.db, mm_got.db, minimock.Diff(*mm_want_ptrs.db, mm_got.db)) + mmCreateDatabase.t.Errorf("ClientMock.CreateDatabase got unexpected parameter db, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateDatabase.CreateDatabaseMock.defaultExpectation.expectationOrigins.originDb, *mm_want_ptrs.db, mm_got.db, minimock.Diff(*mm_want_ptrs.db, mm_got.db)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateDatabase.t.Errorf("ClientMock.CreateDatabase got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateDatabase.t.Errorf("ClientMock.CreateDatabase got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateDatabase.CreateDatabaseMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmCreateDatabase.CreateDatabaseMock.defaultExpectation.results @@ -1433,7 +1610,7 @@ func (m *ClientMock) MinimockCreateDatabaseDone() bool { func (m *ClientMock) MinimockCreateDatabaseInspect() { for _, e := range m.CreateDatabaseMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.CreateDatabase with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.CreateDatabase at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -1441,19 +1618,19 @@ func (m *ClientMock) MinimockCreateDatabaseInspect() { // if default expectation was set then invocations count should be greater than zero if m.CreateDatabaseMock.defaultExpectation != nil && afterCreateDatabaseCounter < 1 { if m.CreateDatabaseMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.CreateDatabase") + m.t.Errorf("Expected call to ClientMock.CreateDatabase at\n%s", m.CreateDatabaseMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.CreateDatabase with params: %#v", *m.CreateDatabaseMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.CreateDatabase at\n%s with params: %#v", m.CreateDatabaseMock.defaultExpectation.expectationOrigins.origin, *m.CreateDatabaseMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcCreateDatabase != nil && afterCreateDatabaseCounter < 1 { - m.t.Error("Expected call to ClientMock.CreateDatabase") + m.t.Errorf("Expected call to ClientMock.CreateDatabase at\n%s", m.funcCreateDatabaseOrigin) } if !m.CreateDatabaseMock.invocationsDone() && afterCreateDatabaseCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.CreateDatabase but found %d calls", - mm_atomic.LoadUint64(&m.CreateDatabaseMock.expectedInvocations), afterCreateDatabaseCounter) + m.t.Errorf("Expected %d calls to ClientMock.CreateDatabase at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateDatabaseMock.expectedInvocations), m.CreateDatabaseMock.expectedInvocationsOrigin, afterCreateDatabaseCounter) } } @@ -1466,16 +1643,19 @@ type mClientMockCreateQueryEndpoint struct { callArgs []*ClientMockCreateQueryEndpointParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockCreateQueryEndpointExpectation specifies expectation struct of the Client.CreateQueryEndpoint type ClientMockCreateQueryEndpointExpectation struct { - mock *ClientMock - params *ClientMockCreateQueryEndpointParams - paramPtrs *ClientMockCreateQueryEndpointParamPtrs - results *ClientMockCreateQueryEndpointResults - Counter uint64 + mock *ClientMock + params *ClientMockCreateQueryEndpointParams + paramPtrs *ClientMockCreateQueryEndpointParamPtrs + expectationOrigins ClientMockCreateQueryEndpointExpectationOrigins + results *ClientMockCreateQueryEndpointResults + returnOrigin string + Counter uint64 } // ClientMockCreateQueryEndpointParams contains parameters of the Client.CreateQueryEndpoint @@ -1498,6 +1678,14 @@ type ClientMockCreateQueryEndpointResults struct { err error } +// ClientMockCreateQueryEndpointOrigins contains origins of expectations of the Client.CreateQueryEndpoint +type ClientMockCreateQueryEndpointExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originEndpoint string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -1523,6 +1711,7 @@ func (mmCreateQueryEndpoint *mClientMockCreateQueryEndpoint) Expect(ctx context. } mmCreateQueryEndpoint.defaultExpectation.params = &ClientMockCreateQueryEndpointParams{ctx, serviceID, endpoint} + mmCreateQueryEndpoint.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmCreateQueryEndpoint.expectations { if minimock.Equal(e.params, mmCreateQueryEndpoint.defaultExpectation.params) { mmCreateQueryEndpoint.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateQueryEndpoint.defaultExpectation.params) @@ -1550,6 +1739,7 @@ func (mmCreateQueryEndpoint *mClientMockCreateQueryEndpoint) ExpectCtxParam1(ctx mmCreateQueryEndpoint.defaultExpectation.paramPtrs = &ClientMockCreateQueryEndpointParamPtrs{} } mmCreateQueryEndpoint.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateQueryEndpoint.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmCreateQueryEndpoint } @@ -1572,6 +1762,7 @@ func (mmCreateQueryEndpoint *mClientMockCreateQueryEndpoint) ExpectServiceIDPara mmCreateQueryEndpoint.defaultExpectation.paramPtrs = &ClientMockCreateQueryEndpointParamPtrs{} } mmCreateQueryEndpoint.defaultExpectation.paramPtrs.serviceID = &serviceID + mmCreateQueryEndpoint.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmCreateQueryEndpoint } @@ -1594,6 +1785,7 @@ func (mmCreateQueryEndpoint *mClientMockCreateQueryEndpoint) ExpectEndpointParam mmCreateQueryEndpoint.defaultExpectation.paramPtrs = &ClientMockCreateQueryEndpointParamPtrs{} } mmCreateQueryEndpoint.defaultExpectation.paramPtrs.endpoint = &endpoint + mmCreateQueryEndpoint.defaultExpectation.expectationOrigins.originEndpoint = minimock.CallerInfo(1) return mmCreateQueryEndpoint } @@ -1619,6 +1811,7 @@ func (mmCreateQueryEndpoint *mClientMockCreateQueryEndpoint) Return(sp1 *Service mmCreateQueryEndpoint.defaultExpectation = &ClientMockCreateQueryEndpointExpectation{mock: mmCreateQueryEndpoint.mock} } mmCreateQueryEndpoint.defaultExpectation.results = &ClientMockCreateQueryEndpointResults{sp1, err} + mmCreateQueryEndpoint.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmCreateQueryEndpoint.mock } @@ -1633,6 +1826,7 @@ func (mmCreateQueryEndpoint *mClientMockCreateQueryEndpoint) Set(f func(ctx cont } mmCreateQueryEndpoint.mock.funcCreateQueryEndpoint = f + mmCreateQueryEndpoint.mock.funcCreateQueryEndpointOrigin = minimock.CallerInfo(1) return mmCreateQueryEndpoint.mock } @@ -1644,8 +1838,9 @@ func (mmCreateQueryEndpoint *mClientMockCreateQueryEndpoint) When(ctx context.Co } expectation := &ClientMockCreateQueryEndpointExpectation{ - mock: mmCreateQueryEndpoint.mock, - params: &ClientMockCreateQueryEndpointParams{ctx, serviceID, endpoint}, + mock: mmCreateQueryEndpoint.mock, + params: &ClientMockCreateQueryEndpointParams{ctx, serviceID, endpoint}, + expectationOrigins: ClientMockCreateQueryEndpointExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmCreateQueryEndpoint.expectations = append(mmCreateQueryEndpoint.expectations, expectation) return expectation @@ -1663,6 +1858,7 @@ func (mmCreateQueryEndpoint *mClientMockCreateQueryEndpoint) Times(n uint64) *mC mmCreateQueryEndpoint.mock.t.Fatalf("Times of ClientMock.CreateQueryEndpoint mock can not be zero") } mm_atomic.StoreUint64(&mmCreateQueryEndpoint.expectedInvocations, n) + mmCreateQueryEndpoint.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmCreateQueryEndpoint } @@ -1682,6 +1878,8 @@ func (mmCreateQueryEndpoint *ClientMock) CreateQueryEndpoint(ctx context.Context mm_atomic.AddUint64(&mmCreateQueryEndpoint.beforeCreateQueryEndpointCounter, 1) defer mm_atomic.AddUint64(&mmCreateQueryEndpoint.afterCreateQueryEndpointCounter, 1) + mmCreateQueryEndpoint.t.Helper() + if mmCreateQueryEndpoint.inspectFuncCreateQueryEndpoint != nil { mmCreateQueryEndpoint.inspectFuncCreateQueryEndpoint(ctx, serviceID, endpoint) } @@ -1710,19 +1908,23 @@ func (mmCreateQueryEndpoint *ClientMock) CreateQueryEndpoint(ctx context.Context if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateQueryEndpoint.t.Errorf("ClientMock.CreateQueryEndpoint got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateQueryEndpoint.t.Errorf("ClientMock.CreateQueryEndpoint got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateQueryEndpoint.CreateQueryEndpointMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmCreateQueryEndpoint.t.Errorf("ClientMock.CreateQueryEndpoint got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmCreateQueryEndpoint.t.Errorf("ClientMock.CreateQueryEndpoint got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateQueryEndpoint.CreateQueryEndpointMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.endpoint != nil && !minimock.Equal(*mm_want_ptrs.endpoint, mm_got.endpoint) { - mmCreateQueryEndpoint.t.Errorf("ClientMock.CreateQueryEndpoint got unexpected parameter endpoint, want: %#v, got: %#v%s\n", *mm_want_ptrs.endpoint, mm_got.endpoint, minimock.Diff(*mm_want_ptrs.endpoint, mm_got.endpoint)) + mmCreateQueryEndpoint.t.Errorf("ClientMock.CreateQueryEndpoint got unexpected parameter endpoint, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateQueryEndpoint.CreateQueryEndpointMock.defaultExpectation.expectationOrigins.originEndpoint, *mm_want_ptrs.endpoint, mm_got.endpoint, minimock.Diff(*mm_want_ptrs.endpoint, mm_got.endpoint)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateQueryEndpoint.t.Errorf("ClientMock.CreateQueryEndpoint got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateQueryEndpoint.t.Errorf("ClientMock.CreateQueryEndpoint got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateQueryEndpoint.CreateQueryEndpointMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmCreateQueryEndpoint.CreateQueryEndpointMock.defaultExpectation.results @@ -1782,7 +1984,7 @@ func (m *ClientMock) MinimockCreateQueryEndpointDone() bool { func (m *ClientMock) MinimockCreateQueryEndpointInspect() { for _, e := range m.CreateQueryEndpointMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.CreateQueryEndpoint with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.CreateQueryEndpoint at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -1790,19 +1992,393 @@ func (m *ClientMock) MinimockCreateQueryEndpointInspect() { // if default expectation was set then invocations count should be greater than zero if m.CreateQueryEndpointMock.defaultExpectation != nil && afterCreateQueryEndpointCounter < 1 { if m.CreateQueryEndpointMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.CreateQueryEndpoint") + m.t.Errorf("Expected call to ClientMock.CreateQueryEndpoint at\n%s", m.CreateQueryEndpointMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.CreateQueryEndpoint with params: %#v", *m.CreateQueryEndpointMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.CreateQueryEndpoint at\n%s with params: %#v", m.CreateQueryEndpointMock.defaultExpectation.expectationOrigins.origin, *m.CreateQueryEndpointMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcCreateQueryEndpoint != nil && afterCreateQueryEndpointCounter < 1 { - m.t.Error("Expected call to ClientMock.CreateQueryEndpoint") + m.t.Errorf("Expected call to ClientMock.CreateQueryEndpoint at\n%s", m.funcCreateQueryEndpointOrigin) } if !m.CreateQueryEndpointMock.invocationsDone() && afterCreateQueryEndpointCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.CreateQueryEndpoint but found %d calls", - mm_atomic.LoadUint64(&m.CreateQueryEndpointMock.expectedInvocations), afterCreateQueryEndpointCounter) + m.t.Errorf("Expected %d calls to ClientMock.CreateQueryEndpoint at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateQueryEndpointMock.expectedInvocations), m.CreateQueryEndpointMock.expectedInvocationsOrigin, afterCreateQueryEndpointCounter) + } +} + +type mClientMockCreateReversePrivateEndpoint struct { + optional bool + mock *ClientMock + defaultExpectation *ClientMockCreateReversePrivateEndpointExpectation + expectations []*ClientMockCreateReversePrivateEndpointExpectation + + callArgs []*ClientMockCreateReversePrivateEndpointParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// ClientMockCreateReversePrivateEndpointExpectation specifies expectation struct of the Client.CreateReversePrivateEndpoint +type ClientMockCreateReversePrivateEndpointExpectation struct { + mock *ClientMock + params *ClientMockCreateReversePrivateEndpointParams + paramPtrs *ClientMockCreateReversePrivateEndpointParamPtrs + expectationOrigins ClientMockCreateReversePrivateEndpointExpectationOrigins + results *ClientMockCreateReversePrivateEndpointResults + returnOrigin string + Counter uint64 +} + +// ClientMockCreateReversePrivateEndpointParams contains parameters of the Client.CreateReversePrivateEndpoint +type ClientMockCreateReversePrivateEndpointParams struct { + ctx context.Context + serviceId string + request CreateReversePrivateEndpoint +} + +// ClientMockCreateReversePrivateEndpointParamPtrs contains pointers to parameters of the Client.CreateReversePrivateEndpoint +type ClientMockCreateReversePrivateEndpointParamPtrs struct { + ctx *context.Context + serviceId *string + request *CreateReversePrivateEndpoint +} + +// ClientMockCreateReversePrivateEndpointResults contains results of the Client.CreateReversePrivateEndpoint +type ClientMockCreateReversePrivateEndpointResults struct { + rp1 *ReversePrivateEndpoint + err error +} + +// ClientMockCreateReversePrivateEndpointOrigins contains origins of expectations of the Client.CreateReversePrivateEndpoint +type ClientMockCreateReversePrivateEndpointExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originRequest string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) Optional() *mClientMockCreateReversePrivateEndpoint { + mmCreateReversePrivateEndpoint.optional = true + return mmCreateReversePrivateEndpoint +} + +// Expect sets up expected params for Client.CreateReversePrivateEndpoint +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) Expect(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint) *mClientMockCreateReversePrivateEndpoint { + if mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpoint != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Set") + } + + if mmCreateReversePrivateEndpoint.defaultExpectation == nil { + mmCreateReversePrivateEndpoint.defaultExpectation = &ClientMockCreateReversePrivateEndpointExpectation{} + } + + if mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by ExpectParams functions") + } + + mmCreateReversePrivateEndpoint.defaultExpectation.params = &ClientMockCreateReversePrivateEndpointParams{ctx, serviceId, request} + mmCreateReversePrivateEndpoint.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmCreateReversePrivateEndpoint.expectations { + if minimock.Equal(e.params, mmCreateReversePrivateEndpoint.defaultExpectation.params) { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateReversePrivateEndpoint.defaultExpectation.params) + } + } + + return mmCreateReversePrivateEndpoint +} + +// ExpectCtxParam1 sets up expected param ctx for Client.CreateReversePrivateEndpoint +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) ExpectCtxParam1(ctx context.Context) *mClientMockCreateReversePrivateEndpoint { + if mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpoint != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Set") + } + + if mmCreateReversePrivateEndpoint.defaultExpectation == nil { + mmCreateReversePrivateEndpoint.defaultExpectation = &ClientMockCreateReversePrivateEndpointExpectation{} + } + + if mmCreateReversePrivateEndpoint.defaultExpectation.params != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Expect") + } + + if mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockCreateReversePrivateEndpointParamPtrs{} + } + mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateReversePrivateEndpoint.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmCreateReversePrivateEndpoint +} + +// ExpectServiceIdParam2 sets up expected param serviceId for Client.CreateReversePrivateEndpoint +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) ExpectServiceIdParam2(serviceId string) *mClientMockCreateReversePrivateEndpoint { + if mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpoint != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Set") + } + + if mmCreateReversePrivateEndpoint.defaultExpectation == nil { + mmCreateReversePrivateEndpoint.defaultExpectation = &ClientMockCreateReversePrivateEndpointExpectation{} + } + + if mmCreateReversePrivateEndpoint.defaultExpectation.params != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Expect") + } + + if mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockCreateReversePrivateEndpointParamPtrs{} + } + mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs.serviceId = &serviceId + mmCreateReversePrivateEndpoint.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) + + return mmCreateReversePrivateEndpoint +} + +// ExpectRequestParam3 sets up expected param request for Client.CreateReversePrivateEndpoint +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) ExpectRequestParam3(request CreateReversePrivateEndpoint) *mClientMockCreateReversePrivateEndpoint { + if mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpoint != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Set") + } + + if mmCreateReversePrivateEndpoint.defaultExpectation == nil { + mmCreateReversePrivateEndpoint.defaultExpectation = &ClientMockCreateReversePrivateEndpointExpectation{} + } + + if mmCreateReversePrivateEndpoint.defaultExpectation.params != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Expect") + } + + if mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockCreateReversePrivateEndpointParamPtrs{} + } + mmCreateReversePrivateEndpoint.defaultExpectation.paramPtrs.request = &request + mmCreateReversePrivateEndpoint.defaultExpectation.expectationOrigins.originRequest = minimock.CallerInfo(1) + + return mmCreateReversePrivateEndpoint +} + +// Inspect accepts an inspector function that has same arguments as the Client.CreateReversePrivateEndpoint +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) Inspect(f func(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint)) *mClientMockCreateReversePrivateEndpoint { + if mmCreateReversePrivateEndpoint.mock.inspectFuncCreateReversePrivateEndpoint != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("Inspect function is already set for ClientMock.CreateReversePrivateEndpoint") + } + + mmCreateReversePrivateEndpoint.mock.inspectFuncCreateReversePrivateEndpoint = f + + return mmCreateReversePrivateEndpoint +} + +// Return sets up results that will be returned by Client.CreateReversePrivateEndpoint +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) Return(rp1 *ReversePrivateEndpoint, err error) *ClientMock { + if mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpoint != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Set") + } + + if mmCreateReversePrivateEndpoint.defaultExpectation == nil { + mmCreateReversePrivateEndpoint.defaultExpectation = &ClientMockCreateReversePrivateEndpointExpectation{mock: mmCreateReversePrivateEndpoint.mock} + } + mmCreateReversePrivateEndpoint.defaultExpectation.results = &ClientMockCreateReversePrivateEndpointResults{rp1, err} + mmCreateReversePrivateEndpoint.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmCreateReversePrivateEndpoint.mock +} + +// Set uses given function f to mock the Client.CreateReversePrivateEndpoint method +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) Set(f func(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint) (rp1 *ReversePrivateEndpoint, err error)) *ClientMock { + if mmCreateReversePrivateEndpoint.defaultExpectation != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("Default expectation is already set for the Client.CreateReversePrivateEndpoint method") + } + + if len(mmCreateReversePrivateEndpoint.expectations) > 0 { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("Some expectations are already set for the Client.CreateReversePrivateEndpoint method") + } + + mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpoint = f + mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpointOrigin = minimock.CallerInfo(1) + return mmCreateReversePrivateEndpoint.mock +} + +// When sets expectation for the Client.CreateReversePrivateEndpoint which will trigger the result defined by the following +// Then helper +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) When(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint) *ClientMockCreateReversePrivateEndpointExpectation { + if mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpoint != nil { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("ClientMock.CreateReversePrivateEndpoint mock is already set by Set") + } + + expectation := &ClientMockCreateReversePrivateEndpointExpectation{ + mock: mmCreateReversePrivateEndpoint.mock, + params: &ClientMockCreateReversePrivateEndpointParams{ctx, serviceId, request}, + expectationOrigins: ClientMockCreateReversePrivateEndpointExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmCreateReversePrivateEndpoint.expectations = append(mmCreateReversePrivateEndpoint.expectations, expectation) + return expectation +} + +// Then sets up Client.CreateReversePrivateEndpoint return parameters for the expectation previously defined by the When method +func (e *ClientMockCreateReversePrivateEndpointExpectation) Then(rp1 *ReversePrivateEndpoint, err error) *ClientMock { + e.results = &ClientMockCreateReversePrivateEndpointResults{rp1, err} + return e.mock +} + +// Times sets number of times Client.CreateReversePrivateEndpoint should be invoked +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) Times(n uint64) *mClientMockCreateReversePrivateEndpoint { + if n == 0 { + mmCreateReversePrivateEndpoint.mock.t.Fatalf("Times of ClientMock.CreateReversePrivateEndpoint mock can not be zero") + } + mm_atomic.StoreUint64(&mmCreateReversePrivateEndpoint.expectedInvocations, n) + mmCreateReversePrivateEndpoint.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmCreateReversePrivateEndpoint +} + +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) invocationsDone() bool { + if len(mmCreateReversePrivateEndpoint.expectations) == 0 && mmCreateReversePrivateEndpoint.defaultExpectation == nil && mmCreateReversePrivateEndpoint.mock.funcCreateReversePrivateEndpoint == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmCreateReversePrivateEndpoint.mock.afterCreateReversePrivateEndpointCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmCreateReversePrivateEndpoint.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// CreateReversePrivateEndpoint implements Client +func (mmCreateReversePrivateEndpoint *ClientMock) CreateReversePrivateEndpoint(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint) (rp1 *ReversePrivateEndpoint, err error) { + mm_atomic.AddUint64(&mmCreateReversePrivateEndpoint.beforeCreateReversePrivateEndpointCounter, 1) + defer mm_atomic.AddUint64(&mmCreateReversePrivateEndpoint.afterCreateReversePrivateEndpointCounter, 1) + + mmCreateReversePrivateEndpoint.t.Helper() + + if mmCreateReversePrivateEndpoint.inspectFuncCreateReversePrivateEndpoint != nil { + mmCreateReversePrivateEndpoint.inspectFuncCreateReversePrivateEndpoint(ctx, serviceId, request) + } + + mm_params := ClientMockCreateReversePrivateEndpointParams{ctx, serviceId, request} + + // Record call args + mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.mutex.Lock() + mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.callArgs = append(mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.callArgs, &mm_params) + mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.mutex.Unlock() + + for _, e := range mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.rp1, e.results.err + } + } + + if mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation.Counter, 1) + mm_want := mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation.params + mm_want_ptrs := mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation.paramPtrs + + mm_got := ClientMockCreateReversePrivateEndpointParams{ctx, serviceId, request} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmCreateReversePrivateEndpoint.t.Errorf("ClientMock.CreateReversePrivateEndpoint got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { + mmCreateReversePrivateEndpoint.t.Errorf("ClientMock.CreateReversePrivateEndpoint got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + } + + if mm_want_ptrs.request != nil && !minimock.Equal(*mm_want_ptrs.request, mm_got.request) { + mmCreateReversePrivateEndpoint.t.Errorf("ClientMock.CreateReversePrivateEndpoint got unexpected parameter request, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originRequest, *mm_want_ptrs.request, mm_got.request, minimock.Diff(*mm_want_ptrs.request, mm_got.request)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmCreateReversePrivateEndpoint.t.Errorf("ClientMock.CreateReversePrivateEndpoint got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmCreateReversePrivateEndpoint.CreateReversePrivateEndpointMock.defaultExpectation.results + if mm_results == nil { + mmCreateReversePrivateEndpoint.t.Fatal("No results are set for the ClientMock.CreateReversePrivateEndpoint") + } + return (*mm_results).rp1, (*mm_results).err + } + if mmCreateReversePrivateEndpoint.funcCreateReversePrivateEndpoint != nil { + return mmCreateReversePrivateEndpoint.funcCreateReversePrivateEndpoint(ctx, serviceId, request) + } + mmCreateReversePrivateEndpoint.t.Fatalf("Unexpected call to ClientMock.CreateReversePrivateEndpoint. %v %v %v", ctx, serviceId, request) + return +} + +// CreateReversePrivateEndpointAfterCounter returns a count of finished ClientMock.CreateReversePrivateEndpoint invocations +func (mmCreateReversePrivateEndpoint *ClientMock) CreateReversePrivateEndpointAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateReversePrivateEndpoint.afterCreateReversePrivateEndpointCounter) +} + +// CreateReversePrivateEndpointBeforeCounter returns a count of ClientMock.CreateReversePrivateEndpoint invocations +func (mmCreateReversePrivateEndpoint *ClientMock) CreateReversePrivateEndpointBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmCreateReversePrivateEndpoint.beforeCreateReversePrivateEndpointCounter) +} + +// Calls returns a list of arguments used in each call to ClientMock.CreateReversePrivateEndpoint. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmCreateReversePrivateEndpoint *mClientMockCreateReversePrivateEndpoint) Calls() []*ClientMockCreateReversePrivateEndpointParams { + mmCreateReversePrivateEndpoint.mutex.RLock() + + argCopy := make([]*ClientMockCreateReversePrivateEndpointParams, len(mmCreateReversePrivateEndpoint.callArgs)) + copy(argCopy, mmCreateReversePrivateEndpoint.callArgs) + + mmCreateReversePrivateEndpoint.mutex.RUnlock() + + return argCopy +} + +// MinimockCreateReversePrivateEndpointDone returns true if the count of the CreateReversePrivateEndpoint invocations corresponds +// the number of defined expectations +func (m *ClientMock) MinimockCreateReversePrivateEndpointDone() bool { + if m.CreateReversePrivateEndpointMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.CreateReversePrivateEndpointMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.CreateReversePrivateEndpointMock.invocationsDone() +} + +// MinimockCreateReversePrivateEndpointInspect logs each unmet expectation +func (m *ClientMock) MinimockCreateReversePrivateEndpointInspect() { + for _, e := range m.CreateReversePrivateEndpointMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to ClientMock.CreateReversePrivateEndpoint at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterCreateReversePrivateEndpointCounter := mm_atomic.LoadUint64(&m.afterCreateReversePrivateEndpointCounter) + // if default expectation was set then invocations count should be greater than zero + if m.CreateReversePrivateEndpointMock.defaultExpectation != nil && afterCreateReversePrivateEndpointCounter < 1 { + if m.CreateReversePrivateEndpointMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to ClientMock.CreateReversePrivateEndpoint at\n%s", m.CreateReversePrivateEndpointMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to ClientMock.CreateReversePrivateEndpoint at\n%s with params: %#v", m.CreateReversePrivateEndpointMock.defaultExpectation.expectationOrigins.origin, *m.CreateReversePrivateEndpointMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcCreateReversePrivateEndpoint != nil && afterCreateReversePrivateEndpointCounter < 1 { + m.t.Errorf("Expected call to ClientMock.CreateReversePrivateEndpoint at\n%s", m.funcCreateReversePrivateEndpointOrigin) + } + + if !m.CreateReversePrivateEndpointMock.invocationsDone() && afterCreateReversePrivateEndpointCounter > 0 { + m.t.Errorf("Expected %d calls to ClientMock.CreateReversePrivateEndpoint at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateReversePrivateEndpointMock.expectedInvocations), m.CreateReversePrivateEndpointMock.expectedInvocationsOrigin, afterCreateReversePrivateEndpointCounter) } } @@ -1815,16 +2391,19 @@ type mClientMockCreateRole struct { callArgs []*ClientMockCreateRoleParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockCreateRoleExpectation specifies expectation struct of the Client.CreateRole type ClientMockCreateRoleExpectation struct { - mock *ClientMock - params *ClientMockCreateRoleParams - paramPtrs *ClientMockCreateRoleParamPtrs - results *ClientMockCreateRoleResults - Counter uint64 + mock *ClientMock + params *ClientMockCreateRoleParams + paramPtrs *ClientMockCreateRoleParamPtrs + expectationOrigins ClientMockCreateRoleExpectationOrigins + results *ClientMockCreateRoleResults + returnOrigin string + Counter uint64 } // ClientMockCreateRoleParams contains parameters of the Client.CreateRole @@ -1847,6 +2426,14 @@ type ClientMockCreateRoleResults struct { err error } +// ClientMockCreateRoleOrigins contains origins of expectations of the Client.CreateRole +type ClientMockCreateRoleExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originRole string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -1872,6 +2459,7 @@ func (mmCreateRole *mClientMockCreateRole) Expect(ctx context.Context, serviceId } mmCreateRole.defaultExpectation.params = &ClientMockCreateRoleParams{ctx, serviceId, role} + mmCreateRole.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmCreateRole.expectations { if minimock.Equal(e.params, mmCreateRole.defaultExpectation.params) { mmCreateRole.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateRole.defaultExpectation.params) @@ -1899,6 +2487,7 @@ func (mmCreateRole *mClientMockCreateRole) ExpectCtxParam1(ctx context.Context) mmCreateRole.defaultExpectation.paramPtrs = &ClientMockCreateRoleParamPtrs{} } mmCreateRole.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateRole.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmCreateRole } @@ -1921,6 +2510,7 @@ func (mmCreateRole *mClientMockCreateRole) ExpectServiceIdParam2(serviceId strin mmCreateRole.defaultExpectation.paramPtrs = &ClientMockCreateRoleParamPtrs{} } mmCreateRole.defaultExpectation.paramPtrs.serviceId = &serviceId + mmCreateRole.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmCreateRole } @@ -1943,6 +2533,7 @@ func (mmCreateRole *mClientMockCreateRole) ExpectRoleParam3(role Role) *mClientM mmCreateRole.defaultExpectation.paramPtrs = &ClientMockCreateRoleParamPtrs{} } mmCreateRole.defaultExpectation.paramPtrs.role = &role + mmCreateRole.defaultExpectation.expectationOrigins.originRole = minimock.CallerInfo(1) return mmCreateRole } @@ -1968,6 +2559,7 @@ func (mmCreateRole *mClientMockCreateRole) Return(rp1 *Role, err error) *ClientM mmCreateRole.defaultExpectation = &ClientMockCreateRoleExpectation{mock: mmCreateRole.mock} } mmCreateRole.defaultExpectation.results = &ClientMockCreateRoleResults{rp1, err} + mmCreateRole.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmCreateRole.mock } @@ -1982,6 +2574,7 @@ func (mmCreateRole *mClientMockCreateRole) Set(f func(ctx context.Context, servi } mmCreateRole.mock.funcCreateRole = f + mmCreateRole.mock.funcCreateRoleOrigin = minimock.CallerInfo(1) return mmCreateRole.mock } @@ -1993,8 +2586,9 @@ func (mmCreateRole *mClientMockCreateRole) When(ctx context.Context, serviceId s } expectation := &ClientMockCreateRoleExpectation{ - mock: mmCreateRole.mock, - params: &ClientMockCreateRoleParams{ctx, serviceId, role}, + mock: mmCreateRole.mock, + params: &ClientMockCreateRoleParams{ctx, serviceId, role}, + expectationOrigins: ClientMockCreateRoleExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmCreateRole.expectations = append(mmCreateRole.expectations, expectation) return expectation @@ -2012,6 +2606,7 @@ func (mmCreateRole *mClientMockCreateRole) Times(n uint64) *mClientMockCreateRol mmCreateRole.mock.t.Fatalf("Times of ClientMock.CreateRole mock can not be zero") } mm_atomic.StoreUint64(&mmCreateRole.expectedInvocations, n) + mmCreateRole.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmCreateRole } @@ -2031,6 +2626,8 @@ func (mmCreateRole *ClientMock) CreateRole(ctx context.Context, serviceId string mm_atomic.AddUint64(&mmCreateRole.beforeCreateRoleCounter, 1) defer mm_atomic.AddUint64(&mmCreateRole.afterCreateRoleCounter, 1) + mmCreateRole.t.Helper() + if mmCreateRole.inspectFuncCreateRole != nil { mmCreateRole.inspectFuncCreateRole(ctx, serviceId, role) } @@ -2059,19 +2656,23 @@ func (mmCreateRole *ClientMock) CreateRole(ctx context.Context, serviceId string if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateRole.t.Errorf("ClientMock.CreateRole got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateRole.t.Errorf("ClientMock.CreateRole got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateRole.CreateRoleMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmCreateRole.t.Errorf("ClientMock.CreateRole got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmCreateRole.t.Errorf("ClientMock.CreateRole got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateRole.CreateRoleMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.role != nil && !minimock.Equal(*mm_want_ptrs.role, mm_got.role) { - mmCreateRole.t.Errorf("ClientMock.CreateRole got unexpected parameter role, want: %#v, got: %#v%s\n", *mm_want_ptrs.role, mm_got.role, minimock.Diff(*mm_want_ptrs.role, mm_got.role)) + mmCreateRole.t.Errorf("ClientMock.CreateRole got unexpected parameter role, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateRole.CreateRoleMock.defaultExpectation.expectationOrigins.originRole, *mm_want_ptrs.role, mm_got.role, minimock.Diff(*mm_want_ptrs.role, mm_got.role)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateRole.t.Errorf("ClientMock.CreateRole got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateRole.t.Errorf("ClientMock.CreateRole got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateRole.CreateRoleMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmCreateRole.CreateRoleMock.defaultExpectation.results @@ -2131,7 +2732,7 @@ func (m *ClientMock) MinimockCreateRoleDone() bool { func (m *ClientMock) MinimockCreateRoleInspect() { for _, e := range m.CreateRoleMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.CreateRole with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.CreateRole at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -2139,19 +2740,19 @@ func (m *ClientMock) MinimockCreateRoleInspect() { // if default expectation was set then invocations count should be greater than zero if m.CreateRoleMock.defaultExpectation != nil && afterCreateRoleCounter < 1 { if m.CreateRoleMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.CreateRole") + m.t.Errorf("Expected call to ClientMock.CreateRole at\n%s", m.CreateRoleMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.CreateRole with params: %#v", *m.CreateRoleMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.CreateRole at\n%s with params: %#v", m.CreateRoleMock.defaultExpectation.expectationOrigins.origin, *m.CreateRoleMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcCreateRole != nil && afterCreateRoleCounter < 1 { - m.t.Error("Expected call to ClientMock.CreateRole") + m.t.Errorf("Expected call to ClientMock.CreateRole at\n%s", m.funcCreateRoleOrigin) } if !m.CreateRoleMock.invocationsDone() && afterCreateRoleCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.CreateRole but found %d calls", - mm_atomic.LoadUint64(&m.CreateRoleMock.expectedInvocations), afterCreateRoleCounter) + m.t.Errorf("Expected %d calls to ClientMock.CreateRole at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateRoleMock.expectedInvocations), m.CreateRoleMock.expectedInvocationsOrigin, afterCreateRoleCounter) } } @@ -2164,16 +2765,19 @@ type mClientMockCreateService struct { callArgs []*ClientMockCreateServiceParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockCreateServiceExpectation specifies expectation struct of the Client.CreateService type ClientMockCreateServiceExpectation struct { - mock *ClientMock - params *ClientMockCreateServiceParams - paramPtrs *ClientMockCreateServiceParamPtrs - results *ClientMockCreateServiceResults - Counter uint64 + mock *ClientMock + params *ClientMockCreateServiceParams + paramPtrs *ClientMockCreateServiceParamPtrs + expectationOrigins ClientMockCreateServiceExpectationOrigins + results *ClientMockCreateServiceResults + returnOrigin string + Counter uint64 } // ClientMockCreateServiceParams contains parameters of the Client.CreateService @@ -2195,6 +2799,13 @@ type ClientMockCreateServiceResults struct { err error } +// ClientMockCreateServiceOrigins contains origins of expectations of the Client.CreateService +type ClientMockCreateServiceExpectationOrigins struct { + origin string + originCtx string + originS string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -2220,6 +2831,7 @@ func (mmCreateService *mClientMockCreateService) Expect(ctx context.Context, s S } mmCreateService.defaultExpectation.params = &ClientMockCreateServiceParams{ctx, s} + mmCreateService.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmCreateService.expectations { if minimock.Equal(e.params, mmCreateService.defaultExpectation.params) { mmCreateService.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateService.defaultExpectation.params) @@ -2247,6 +2859,7 @@ func (mmCreateService *mClientMockCreateService) ExpectCtxParam1(ctx context.Con mmCreateService.defaultExpectation.paramPtrs = &ClientMockCreateServiceParamPtrs{} } mmCreateService.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateService.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmCreateService } @@ -2269,6 +2882,7 @@ func (mmCreateService *mClientMockCreateService) ExpectSParam2(s Service) *mClie mmCreateService.defaultExpectation.paramPtrs = &ClientMockCreateServiceParamPtrs{} } mmCreateService.defaultExpectation.paramPtrs.s = &s + mmCreateService.defaultExpectation.expectationOrigins.originS = minimock.CallerInfo(1) return mmCreateService } @@ -2294,6 +2908,7 @@ func (mmCreateService *mClientMockCreateService) Return(sp1 *Service, s1 string, mmCreateService.defaultExpectation = &ClientMockCreateServiceExpectation{mock: mmCreateService.mock} } mmCreateService.defaultExpectation.results = &ClientMockCreateServiceResults{sp1, s1, err} + mmCreateService.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmCreateService.mock } @@ -2308,6 +2923,7 @@ func (mmCreateService *mClientMockCreateService) Set(f func(ctx context.Context, } mmCreateService.mock.funcCreateService = f + mmCreateService.mock.funcCreateServiceOrigin = minimock.CallerInfo(1) return mmCreateService.mock } @@ -2319,8 +2935,9 @@ func (mmCreateService *mClientMockCreateService) When(ctx context.Context, s Ser } expectation := &ClientMockCreateServiceExpectation{ - mock: mmCreateService.mock, - params: &ClientMockCreateServiceParams{ctx, s}, + mock: mmCreateService.mock, + params: &ClientMockCreateServiceParams{ctx, s}, + expectationOrigins: ClientMockCreateServiceExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmCreateService.expectations = append(mmCreateService.expectations, expectation) return expectation @@ -2338,6 +2955,7 @@ func (mmCreateService *mClientMockCreateService) Times(n uint64) *mClientMockCre mmCreateService.mock.t.Fatalf("Times of ClientMock.CreateService mock can not be zero") } mm_atomic.StoreUint64(&mmCreateService.expectedInvocations, n) + mmCreateService.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmCreateService } @@ -2357,6 +2975,8 @@ func (mmCreateService *ClientMock) CreateService(ctx context.Context, s Service) mm_atomic.AddUint64(&mmCreateService.beforeCreateServiceCounter, 1) defer mm_atomic.AddUint64(&mmCreateService.afterCreateServiceCounter, 1) + mmCreateService.t.Helper() + if mmCreateService.inspectFuncCreateService != nil { mmCreateService.inspectFuncCreateService(ctx, s) } @@ -2385,15 +3005,18 @@ func (mmCreateService *ClientMock) CreateService(ctx context.Context, s Service) if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateService.t.Errorf("ClientMock.CreateService got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateService.t.Errorf("ClientMock.CreateService got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateService.CreateServiceMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.s != nil && !minimock.Equal(*mm_want_ptrs.s, mm_got.s) { - mmCreateService.t.Errorf("ClientMock.CreateService got unexpected parameter s, want: %#v, got: %#v%s\n", *mm_want_ptrs.s, mm_got.s, minimock.Diff(*mm_want_ptrs.s, mm_got.s)) + mmCreateService.t.Errorf("ClientMock.CreateService got unexpected parameter s, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateService.CreateServiceMock.defaultExpectation.expectationOrigins.originS, *mm_want_ptrs.s, mm_got.s, minimock.Diff(*mm_want_ptrs.s, mm_got.s)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateService.t.Errorf("ClientMock.CreateService got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateService.t.Errorf("ClientMock.CreateService got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateService.CreateServiceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmCreateService.CreateServiceMock.defaultExpectation.results @@ -2453,7 +3076,7 @@ func (m *ClientMock) MinimockCreateServiceDone() bool { func (m *ClientMock) MinimockCreateServiceInspect() { for _, e := range m.CreateServiceMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.CreateService with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.CreateService at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -2461,19 +3084,19 @@ func (m *ClientMock) MinimockCreateServiceInspect() { // if default expectation was set then invocations count should be greater than zero if m.CreateServiceMock.defaultExpectation != nil && afterCreateServiceCounter < 1 { if m.CreateServiceMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.CreateService") + m.t.Errorf("Expected call to ClientMock.CreateService at\n%s", m.CreateServiceMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.CreateService with params: %#v", *m.CreateServiceMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.CreateService at\n%s with params: %#v", m.CreateServiceMock.defaultExpectation.expectationOrigins.origin, *m.CreateServiceMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcCreateService != nil && afterCreateServiceCounter < 1 { - m.t.Error("Expected call to ClientMock.CreateService") + m.t.Errorf("Expected call to ClientMock.CreateService at\n%s", m.funcCreateServiceOrigin) } if !m.CreateServiceMock.invocationsDone() && afterCreateServiceCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.CreateService but found %d calls", - mm_atomic.LoadUint64(&m.CreateServiceMock.expectedInvocations), afterCreateServiceCounter) + m.t.Errorf("Expected %d calls to ClientMock.CreateService at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateServiceMock.expectedInvocations), m.CreateServiceMock.expectedInvocationsOrigin, afterCreateServiceCounter) } } @@ -2486,16 +3109,19 @@ type mClientMockCreateUser struct { callArgs []*ClientMockCreateUserParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockCreateUserExpectation specifies expectation struct of the Client.CreateUser type ClientMockCreateUserExpectation struct { - mock *ClientMock - params *ClientMockCreateUserParams - paramPtrs *ClientMockCreateUserParamPtrs - results *ClientMockCreateUserResults - Counter uint64 + mock *ClientMock + params *ClientMockCreateUserParams + paramPtrs *ClientMockCreateUserParamPtrs + expectationOrigins ClientMockCreateUserExpectationOrigins + results *ClientMockCreateUserResults + returnOrigin string + Counter uint64 } // ClientMockCreateUserParams contains parameters of the Client.CreateUser @@ -2518,6 +3144,14 @@ type ClientMockCreateUserResults struct { err error } +// ClientMockCreateUserOrigins contains origins of expectations of the Client.CreateUser +type ClientMockCreateUserExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originUser string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -2543,6 +3177,7 @@ func (mmCreateUser *mClientMockCreateUser) Expect(ctx context.Context, serviceId } mmCreateUser.defaultExpectation.params = &ClientMockCreateUserParams{ctx, serviceId, user} + mmCreateUser.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmCreateUser.expectations { if minimock.Equal(e.params, mmCreateUser.defaultExpectation.params) { mmCreateUser.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateUser.defaultExpectation.params) @@ -2570,6 +3205,7 @@ func (mmCreateUser *mClientMockCreateUser) ExpectCtxParam1(ctx context.Context) mmCreateUser.defaultExpectation.paramPtrs = &ClientMockCreateUserParamPtrs{} } mmCreateUser.defaultExpectation.paramPtrs.ctx = &ctx + mmCreateUser.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmCreateUser } @@ -2592,6 +3228,7 @@ func (mmCreateUser *mClientMockCreateUser) ExpectServiceIdParam2(serviceId strin mmCreateUser.defaultExpectation.paramPtrs = &ClientMockCreateUserParamPtrs{} } mmCreateUser.defaultExpectation.paramPtrs.serviceId = &serviceId + mmCreateUser.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmCreateUser } @@ -2614,6 +3251,7 @@ func (mmCreateUser *mClientMockCreateUser) ExpectUserParam3(user User) *mClientM mmCreateUser.defaultExpectation.paramPtrs = &ClientMockCreateUserParamPtrs{} } mmCreateUser.defaultExpectation.paramPtrs.user = &user + mmCreateUser.defaultExpectation.expectationOrigins.originUser = minimock.CallerInfo(1) return mmCreateUser } @@ -2639,6 +3277,7 @@ func (mmCreateUser *mClientMockCreateUser) Return(up1 *User, err error) *ClientM mmCreateUser.defaultExpectation = &ClientMockCreateUserExpectation{mock: mmCreateUser.mock} } mmCreateUser.defaultExpectation.results = &ClientMockCreateUserResults{up1, err} + mmCreateUser.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmCreateUser.mock } @@ -2653,6 +3292,7 @@ func (mmCreateUser *mClientMockCreateUser) Set(f func(ctx context.Context, servi } mmCreateUser.mock.funcCreateUser = f + mmCreateUser.mock.funcCreateUserOrigin = minimock.CallerInfo(1) return mmCreateUser.mock } @@ -2664,8 +3304,9 @@ func (mmCreateUser *mClientMockCreateUser) When(ctx context.Context, serviceId s } expectation := &ClientMockCreateUserExpectation{ - mock: mmCreateUser.mock, - params: &ClientMockCreateUserParams{ctx, serviceId, user}, + mock: mmCreateUser.mock, + params: &ClientMockCreateUserParams{ctx, serviceId, user}, + expectationOrigins: ClientMockCreateUserExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmCreateUser.expectations = append(mmCreateUser.expectations, expectation) return expectation @@ -2683,6 +3324,7 @@ func (mmCreateUser *mClientMockCreateUser) Times(n uint64) *mClientMockCreateUse mmCreateUser.mock.t.Fatalf("Times of ClientMock.CreateUser mock can not be zero") } mm_atomic.StoreUint64(&mmCreateUser.expectedInvocations, n) + mmCreateUser.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmCreateUser } @@ -2702,6 +3344,8 @@ func (mmCreateUser *ClientMock) CreateUser(ctx context.Context, serviceId string mm_atomic.AddUint64(&mmCreateUser.beforeCreateUserCounter, 1) defer mm_atomic.AddUint64(&mmCreateUser.afterCreateUserCounter, 1) + mmCreateUser.t.Helper() + if mmCreateUser.inspectFuncCreateUser != nil { mmCreateUser.inspectFuncCreateUser(ctx, serviceId, user) } @@ -2730,19 +3374,23 @@ func (mmCreateUser *ClientMock) CreateUser(ctx context.Context, serviceId string if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmCreateUser.t.Errorf("ClientMock.CreateUser got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmCreateUser.t.Errorf("ClientMock.CreateUser got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateUser.CreateUserMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmCreateUser.t.Errorf("ClientMock.CreateUser got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmCreateUser.t.Errorf("ClientMock.CreateUser got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateUser.CreateUserMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.user != nil && !minimock.Equal(*mm_want_ptrs.user, mm_got.user) { - mmCreateUser.t.Errorf("ClientMock.CreateUser got unexpected parameter user, want: %#v, got: %#v%s\n", *mm_want_ptrs.user, mm_got.user, minimock.Diff(*mm_want_ptrs.user, mm_got.user)) + mmCreateUser.t.Errorf("ClientMock.CreateUser got unexpected parameter user, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateUser.CreateUserMock.defaultExpectation.expectationOrigins.originUser, *mm_want_ptrs.user, mm_got.user, minimock.Diff(*mm_want_ptrs.user, mm_got.user)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmCreateUser.t.Errorf("ClientMock.CreateUser got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmCreateUser.t.Errorf("ClientMock.CreateUser got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmCreateUser.CreateUserMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmCreateUser.CreateUserMock.defaultExpectation.results @@ -2802,7 +3450,7 @@ func (m *ClientMock) MinimockCreateUserDone() bool { func (m *ClientMock) MinimockCreateUserInspect() { for _, e := range m.CreateUserMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.CreateUser with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.CreateUser at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -2810,19 +3458,19 @@ func (m *ClientMock) MinimockCreateUserInspect() { // if default expectation was set then invocations count should be greater than zero if m.CreateUserMock.defaultExpectation != nil && afterCreateUserCounter < 1 { if m.CreateUserMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.CreateUser") + m.t.Errorf("Expected call to ClientMock.CreateUser at\n%s", m.CreateUserMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.CreateUser with params: %#v", *m.CreateUserMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.CreateUser at\n%s with params: %#v", m.CreateUserMock.defaultExpectation.expectationOrigins.origin, *m.CreateUserMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcCreateUser != nil && afterCreateUserCounter < 1 { - m.t.Error("Expected call to ClientMock.CreateUser") + m.t.Errorf("Expected call to ClientMock.CreateUser at\n%s", m.funcCreateUserOrigin) } if !m.CreateUserMock.invocationsDone() && afterCreateUserCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.CreateUser but found %d calls", - mm_atomic.LoadUint64(&m.CreateUserMock.expectedInvocations), afterCreateUserCounter) + m.t.Errorf("Expected %d calls to ClientMock.CreateUser at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.CreateUserMock.expectedInvocations), m.CreateUserMock.expectedInvocationsOrigin, afterCreateUserCounter) } } @@ -2835,16 +3483,19 @@ type mClientMockDeleteClickPipe struct { callArgs []*ClientMockDeleteClickPipeParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockDeleteClickPipeExpectation specifies expectation struct of the Client.DeleteClickPipe type ClientMockDeleteClickPipeExpectation struct { - mock *ClientMock - params *ClientMockDeleteClickPipeParams - paramPtrs *ClientMockDeleteClickPipeParamPtrs - results *ClientMockDeleteClickPipeResults - Counter uint64 + mock *ClientMock + params *ClientMockDeleteClickPipeParams + paramPtrs *ClientMockDeleteClickPipeParamPtrs + expectationOrigins ClientMockDeleteClickPipeExpectationOrigins + results *ClientMockDeleteClickPipeResults + returnOrigin string + Counter uint64 } // ClientMockDeleteClickPipeParams contains parameters of the Client.DeleteClickPipe @@ -2866,6 +3517,14 @@ type ClientMockDeleteClickPipeResults struct { err error } +// ClientMockDeleteClickPipeOrigins contains origins of expectations of the Client.DeleteClickPipe +type ClientMockDeleteClickPipeExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originClickPipeId string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -2891,6 +3550,7 @@ func (mmDeleteClickPipe *mClientMockDeleteClickPipe) Expect(ctx context.Context, } mmDeleteClickPipe.defaultExpectation.params = &ClientMockDeleteClickPipeParams{ctx, serviceId, clickPipeId} + mmDeleteClickPipe.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmDeleteClickPipe.expectations { if minimock.Equal(e.params, mmDeleteClickPipe.defaultExpectation.params) { mmDeleteClickPipe.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteClickPipe.defaultExpectation.params) @@ -2918,6 +3578,7 @@ func (mmDeleteClickPipe *mClientMockDeleteClickPipe) ExpectCtxParam1(ctx context mmDeleteClickPipe.defaultExpectation.paramPtrs = &ClientMockDeleteClickPipeParamPtrs{} } mmDeleteClickPipe.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteClickPipe.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmDeleteClickPipe } @@ -2940,6 +3601,7 @@ func (mmDeleteClickPipe *mClientMockDeleteClickPipe) ExpectServiceIdParam2(servi mmDeleteClickPipe.defaultExpectation.paramPtrs = &ClientMockDeleteClickPipeParamPtrs{} } mmDeleteClickPipe.defaultExpectation.paramPtrs.serviceId = &serviceId + mmDeleteClickPipe.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmDeleteClickPipe } @@ -2962,6 +3624,7 @@ func (mmDeleteClickPipe *mClientMockDeleteClickPipe) ExpectClickPipeIdParam3(cli mmDeleteClickPipe.defaultExpectation.paramPtrs = &ClientMockDeleteClickPipeParamPtrs{} } mmDeleteClickPipe.defaultExpectation.paramPtrs.clickPipeId = &clickPipeId + mmDeleteClickPipe.defaultExpectation.expectationOrigins.originClickPipeId = minimock.CallerInfo(1) return mmDeleteClickPipe } @@ -2987,6 +3650,7 @@ func (mmDeleteClickPipe *mClientMockDeleteClickPipe) Return(err error) *ClientMo mmDeleteClickPipe.defaultExpectation = &ClientMockDeleteClickPipeExpectation{mock: mmDeleteClickPipe.mock} } mmDeleteClickPipe.defaultExpectation.results = &ClientMockDeleteClickPipeResults{err} + mmDeleteClickPipe.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmDeleteClickPipe.mock } @@ -3001,6 +3665,7 @@ func (mmDeleteClickPipe *mClientMockDeleteClickPipe) Set(f func(ctx context.Cont } mmDeleteClickPipe.mock.funcDeleteClickPipe = f + mmDeleteClickPipe.mock.funcDeleteClickPipeOrigin = minimock.CallerInfo(1) return mmDeleteClickPipe.mock } @@ -3012,8 +3677,9 @@ func (mmDeleteClickPipe *mClientMockDeleteClickPipe) When(ctx context.Context, s } expectation := &ClientMockDeleteClickPipeExpectation{ - mock: mmDeleteClickPipe.mock, - params: &ClientMockDeleteClickPipeParams{ctx, serviceId, clickPipeId}, + mock: mmDeleteClickPipe.mock, + params: &ClientMockDeleteClickPipeParams{ctx, serviceId, clickPipeId}, + expectationOrigins: ClientMockDeleteClickPipeExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmDeleteClickPipe.expectations = append(mmDeleteClickPipe.expectations, expectation) return expectation @@ -3031,6 +3697,7 @@ func (mmDeleteClickPipe *mClientMockDeleteClickPipe) Times(n uint64) *mClientMoc mmDeleteClickPipe.mock.t.Fatalf("Times of ClientMock.DeleteClickPipe mock can not be zero") } mm_atomic.StoreUint64(&mmDeleteClickPipe.expectedInvocations, n) + mmDeleteClickPipe.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmDeleteClickPipe } @@ -3050,6 +3717,8 @@ func (mmDeleteClickPipe *ClientMock) DeleteClickPipe(ctx context.Context, servic mm_atomic.AddUint64(&mmDeleteClickPipe.beforeDeleteClickPipeCounter, 1) defer mm_atomic.AddUint64(&mmDeleteClickPipe.afterDeleteClickPipeCounter, 1) + mmDeleteClickPipe.t.Helper() + if mmDeleteClickPipe.inspectFuncDeleteClickPipe != nil { mmDeleteClickPipe.inspectFuncDeleteClickPipe(ctx, serviceId, clickPipeId) } @@ -3078,19 +3747,23 @@ func (mmDeleteClickPipe *ClientMock) DeleteClickPipe(ctx context.Context, servic if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteClickPipe.t.Errorf("ClientMock.DeleteClickPipe got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteClickPipe.t.Errorf("ClientMock.DeleteClickPipe got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteClickPipe.DeleteClickPipeMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmDeleteClickPipe.t.Errorf("ClientMock.DeleteClickPipe got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmDeleteClickPipe.t.Errorf("ClientMock.DeleteClickPipe got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteClickPipe.DeleteClickPipeMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.clickPipeId != nil && !minimock.Equal(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId) { - mmDeleteClickPipe.t.Errorf("ClientMock.DeleteClickPipe got unexpected parameter clickPipeId, want: %#v, got: %#v%s\n", *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) + mmDeleteClickPipe.t.Errorf("ClientMock.DeleteClickPipe got unexpected parameter clickPipeId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteClickPipe.DeleteClickPipeMock.defaultExpectation.expectationOrigins.originClickPipeId, *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteClickPipe.t.Errorf("ClientMock.DeleteClickPipe got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteClickPipe.t.Errorf("ClientMock.DeleteClickPipe got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteClickPipe.DeleteClickPipeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmDeleteClickPipe.DeleteClickPipeMock.defaultExpectation.results @@ -3150,7 +3823,7 @@ func (m *ClientMock) MinimockDeleteClickPipeDone() bool { func (m *ClientMock) MinimockDeleteClickPipeInspect() { for _, e := range m.DeleteClickPipeMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.DeleteClickPipe with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.DeleteClickPipe at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -3158,19 +3831,19 @@ func (m *ClientMock) MinimockDeleteClickPipeInspect() { // if default expectation was set then invocations count should be greater than zero if m.DeleteClickPipeMock.defaultExpectation != nil && afterDeleteClickPipeCounter < 1 { if m.DeleteClickPipeMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.DeleteClickPipe") + m.t.Errorf("Expected call to ClientMock.DeleteClickPipe at\n%s", m.DeleteClickPipeMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.DeleteClickPipe with params: %#v", *m.DeleteClickPipeMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.DeleteClickPipe at\n%s with params: %#v", m.DeleteClickPipeMock.defaultExpectation.expectationOrigins.origin, *m.DeleteClickPipeMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcDeleteClickPipe != nil && afterDeleteClickPipeCounter < 1 { - m.t.Error("Expected call to ClientMock.DeleteClickPipe") + m.t.Errorf("Expected call to ClientMock.DeleteClickPipe at\n%s", m.funcDeleteClickPipeOrigin) } if !m.DeleteClickPipeMock.invocationsDone() && afterDeleteClickPipeCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.DeleteClickPipe but found %d calls", - mm_atomic.LoadUint64(&m.DeleteClickPipeMock.expectedInvocations), afterDeleteClickPipeCounter) + m.t.Errorf("Expected %d calls to ClientMock.DeleteClickPipe at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteClickPipeMock.expectedInvocations), m.DeleteClickPipeMock.expectedInvocationsOrigin, afterDeleteClickPipeCounter) } } @@ -3183,16 +3856,19 @@ type mClientMockDeleteDatabase struct { callArgs []*ClientMockDeleteDatabaseParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockDeleteDatabaseExpectation specifies expectation struct of the Client.DeleteDatabase type ClientMockDeleteDatabaseExpectation struct { - mock *ClientMock - params *ClientMockDeleteDatabaseParams - paramPtrs *ClientMockDeleteDatabaseParamPtrs - results *ClientMockDeleteDatabaseResults - Counter uint64 + mock *ClientMock + params *ClientMockDeleteDatabaseParams + paramPtrs *ClientMockDeleteDatabaseParamPtrs + expectationOrigins ClientMockDeleteDatabaseExpectationOrigins + results *ClientMockDeleteDatabaseResults + returnOrigin string + Counter uint64 } // ClientMockDeleteDatabaseParams contains parameters of the Client.DeleteDatabase @@ -3214,6 +3890,14 @@ type ClientMockDeleteDatabaseResults struct { err error } +// ClientMockDeleteDatabaseOrigins contains origins of expectations of the Client.DeleteDatabase +type ClientMockDeleteDatabaseExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -3239,6 +3923,7 @@ func (mmDeleteDatabase *mClientMockDeleteDatabase) Expect(ctx context.Context, s } mmDeleteDatabase.defaultExpectation.params = &ClientMockDeleteDatabaseParams{ctx, serviceID, name} + mmDeleteDatabase.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmDeleteDatabase.expectations { if minimock.Equal(e.params, mmDeleteDatabase.defaultExpectation.params) { mmDeleteDatabase.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteDatabase.defaultExpectation.params) @@ -3266,6 +3951,7 @@ func (mmDeleteDatabase *mClientMockDeleteDatabase) ExpectCtxParam1(ctx context.C mmDeleteDatabase.defaultExpectation.paramPtrs = &ClientMockDeleteDatabaseParamPtrs{} } mmDeleteDatabase.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteDatabase.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmDeleteDatabase } @@ -3288,6 +3974,7 @@ func (mmDeleteDatabase *mClientMockDeleteDatabase) ExpectServiceIDParam2(service mmDeleteDatabase.defaultExpectation.paramPtrs = &ClientMockDeleteDatabaseParamPtrs{} } mmDeleteDatabase.defaultExpectation.paramPtrs.serviceID = &serviceID + mmDeleteDatabase.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmDeleteDatabase } @@ -3310,6 +3997,7 @@ func (mmDeleteDatabase *mClientMockDeleteDatabase) ExpectNameParam3(name string) mmDeleteDatabase.defaultExpectation.paramPtrs = &ClientMockDeleteDatabaseParamPtrs{} } mmDeleteDatabase.defaultExpectation.paramPtrs.name = &name + mmDeleteDatabase.defaultExpectation.expectationOrigins.originName = minimock.CallerInfo(1) return mmDeleteDatabase } @@ -3335,6 +4023,7 @@ func (mmDeleteDatabase *mClientMockDeleteDatabase) Return(err error) *ClientMock mmDeleteDatabase.defaultExpectation = &ClientMockDeleteDatabaseExpectation{mock: mmDeleteDatabase.mock} } mmDeleteDatabase.defaultExpectation.results = &ClientMockDeleteDatabaseResults{err} + mmDeleteDatabase.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmDeleteDatabase.mock } @@ -3349,6 +4038,7 @@ func (mmDeleteDatabase *mClientMockDeleteDatabase) Set(f func(ctx context.Contex } mmDeleteDatabase.mock.funcDeleteDatabase = f + mmDeleteDatabase.mock.funcDeleteDatabaseOrigin = minimock.CallerInfo(1) return mmDeleteDatabase.mock } @@ -3360,8 +4050,9 @@ func (mmDeleteDatabase *mClientMockDeleteDatabase) When(ctx context.Context, ser } expectation := &ClientMockDeleteDatabaseExpectation{ - mock: mmDeleteDatabase.mock, - params: &ClientMockDeleteDatabaseParams{ctx, serviceID, name}, + mock: mmDeleteDatabase.mock, + params: &ClientMockDeleteDatabaseParams{ctx, serviceID, name}, + expectationOrigins: ClientMockDeleteDatabaseExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmDeleteDatabase.expectations = append(mmDeleteDatabase.expectations, expectation) return expectation @@ -3379,6 +4070,7 @@ func (mmDeleteDatabase *mClientMockDeleteDatabase) Times(n uint64) *mClientMockD mmDeleteDatabase.mock.t.Fatalf("Times of ClientMock.DeleteDatabase mock can not be zero") } mm_atomic.StoreUint64(&mmDeleteDatabase.expectedInvocations, n) + mmDeleteDatabase.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmDeleteDatabase } @@ -3398,6 +4090,8 @@ func (mmDeleteDatabase *ClientMock) DeleteDatabase(ctx context.Context, serviceI mm_atomic.AddUint64(&mmDeleteDatabase.beforeDeleteDatabaseCounter, 1) defer mm_atomic.AddUint64(&mmDeleteDatabase.afterDeleteDatabaseCounter, 1) + mmDeleteDatabase.t.Helper() + if mmDeleteDatabase.inspectFuncDeleteDatabase != nil { mmDeleteDatabase.inspectFuncDeleteDatabase(ctx, serviceID, name) } @@ -3426,19 +4120,23 @@ func (mmDeleteDatabase *ClientMock) DeleteDatabase(ctx context.Context, serviceI if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteDatabase.t.Errorf("ClientMock.DeleteDatabase got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteDatabase.t.Errorf("ClientMock.DeleteDatabase got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteDatabase.DeleteDatabaseMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmDeleteDatabase.t.Errorf("ClientMock.DeleteDatabase got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmDeleteDatabase.t.Errorf("ClientMock.DeleteDatabase got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteDatabase.DeleteDatabaseMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.name != nil && !minimock.Equal(*mm_want_ptrs.name, mm_got.name) { - mmDeleteDatabase.t.Errorf("ClientMock.DeleteDatabase got unexpected parameter name, want: %#v, got: %#v%s\n", *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) + mmDeleteDatabase.t.Errorf("ClientMock.DeleteDatabase got unexpected parameter name, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteDatabase.DeleteDatabaseMock.defaultExpectation.expectationOrigins.originName, *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteDatabase.t.Errorf("ClientMock.DeleteDatabase got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteDatabase.t.Errorf("ClientMock.DeleteDatabase got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteDatabase.DeleteDatabaseMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmDeleteDatabase.DeleteDatabaseMock.defaultExpectation.results @@ -3498,7 +4196,7 @@ func (m *ClientMock) MinimockDeleteDatabaseDone() bool { func (m *ClientMock) MinimockDeleteDatabaseInspect() { for _, e := range m.DeleteDatabaseMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.DeleteDatabase with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.DeleteDatabase at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -3506,19 +4204,19 @@ func (m *ClientMock) MinimockDeleteDatabaseInspect() { // if default expectation was set then invocations count should be greater than zero if m.DeleteDatabaseMock.defaultExpectation != nil && afterDeleteDatabaseCounter < 1 { if m.DeleteDatabaseMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.DeleteDatabase") + m.t.Errorf("Expected call to ClientMock.DeleteDatabase at\n%s", m.DeleteDatabaseMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.DeleteDatabase with params: %#v", *m.DeleteDatabaseMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.DeleteDatabase at\n%s with params: %#v", m.DeleteDatabaseMock.defaultExpectation.expectationOrigins.origin, *m.DeleteDatabaseMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcDeleteDatabase != nil && afterDeleteDatabaseCounter < 1 { - m.t.Error("Expected call to ClientMock.DeleteDatabase") + m.t.Errorf("Expected call to ClientMock.DeleteDatabase at\n%s", m.funcDeleteDatabaseOrigin) } if !m.DeleteDatabaseMock.invocationsDone() && afterDeleteDatabaseCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.DeleteDatabase but found %d calls", - mm_atomic.LoadUint64(&m.DeleteDatabaseMock.expectedInvocations), afterDeleteDatabaseCounter) + m.t.Errorf("Expected %d calls to ClientMock.DeleteDatabase at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteDatabaseMock.expectedInvocations), m.DeleteDatabaseMock.expectedInvocationsOrigin, afterDeleteDatabaseCounter) } } @@ -3531,16 +4229,19 @@ type mClientMockDeleteQueryEndpoint struct { callArgs []*ClientMockDeleteQueryEndpointParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockDeleteQueryEndpointExpectation specifies expectation struct of the Client.DeleteQueryEndpoint type ClientMockDeleteQueryEndpointExpectation struct { - mock *ClientMock - params *ClientMockDeleteQueryEndpointParams - paramPtrs *ClientMockDeleteQueryEndpointParamPtrs - results *ClientMockDeleteQueryEndpointResults - Counter uint64 + mock *ClientMock + params *ClientMockDeleteQueryEndpointParams + paramPtrs *ClientMockDeleteQueryEndpointParamPtrs + expectationOrigins ClientMockDeleteQueryEndpointExpectationOrigins + results *ClientMockDeleteQueryEndpointResults + returnOrigin string + Counter uint64 } // ClientMockDeleteQueryEndpointParams contains parameters of the Client.DeleteQueryEndpoint @@ -3560,6 +4261,13 @@ type ClientMockDeleteQueryEndpointResults struct { err error } +// ClientMockDeleteQueryEndpointOrigins contains origins of expectations of the Client.DeleteQueryEndpoint +type ClientMockDeleteQueryEndpointExpectationOrigins struct { + origin string + originCtx string + originServiceID string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -3585,6 +4293,7 @@ func (mmDeleteQueryEndpoint *mClientMockDeleteQueryEndpoint) Expect(ctx context. } mmDeleteQueryEndpoint.defaultExpectation.params = &ClientMockDeleteQueryEndpointParams{ctx, serviceID} + mmDeleteQueryEndpoint.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmDeleteQueryEndpoint.expectations { if minimock.Equal(e.params, mmDeleteQueryEndpoint.defaultExpectation.params) { mmDeleteQueryEndpoint.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteQueryEndpoint.defaultExpectation.params) @@ -3612,6 +4321,7 @@ func (mmDeleteQueryEndpoint *mClientMockDeleteQueryEndpoint) ExpectCtxParam1(ctx mmDeleteQueryEndpoint.defaultExpectation.paramPtrs = &ClientMockDeleteQueryEndpointParamPtrs{} } mmDeleteQueryEndpoint.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteQueryEndpoint.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmDeleteQueryEndpoint } @@ -3634,6 +4344,7 @@ func (mmDeleteQueryEndpoint *mClientMockDeleteQueryEndpoint) ExpectServiceIDPara mmDeleteQueryEndpoint.defaultExpectation.paramPtrs = &ClientMockDeleteQueryEndpointParamPtrs{} } mmDeleteQueryEndpoint.defaultExpectation.paramPtrs.serviceID = &serviceID + mmDeleteQueryEndpoint.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmDeleteQueryEndpoint } @@ -3659,6 +4370,7 @@ func (mmDeleteQueryEndpoint *mClientMockDeleteQueryEndpoint) Return(err error) * mmDeleteQueryEndpoint.defaultExpectation = &ClientMockDeleteQueryEndpointExpectation{mock: mmDeleteQueryEndpoint.mock} } mmDeleteQueryEndpoint.defaultExpectation.results = &ClientMockDeleteQueryEndpointResults{err} + mmDeleteQueryEndpoint.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmDeleteQueryEndpoint.mock } @@ -3673,6 +4385,7 @@ func (mmDeleteQueryEndpoint *mClientMockDeleteQueryEndpoint) Set(f func(ctx cont } mmDeleteQueryEndpoint.mock.funcDeleteQueryEndpoint = f + mmDeleteQueryEndpoint.mock.funcDeleteQueryEndpointOrigin = minimock.CallerInfo(1) return mmDeleteQueryEndpoint.mock } @@ -3684,8 +4397,9 @@ func (mmDeleteQueryEndpoint *mClientMockDeleteQueryEndpoint) When(ctx context.Co } expectation := &ClientMockDeleteQueryEndpointExpectation{ - mock: mmDeleteQueryEndpoint.mock, - params: &ClientMockDeleteQueryEndpointParams{ctx, serviceID}, + mock: mmDeleteQueryEndpoint.mock, + params: &ClientMockDeleteQueryEndpointParams{ctx, serviceID}, + expectationOrigins: ClientMockDeleteQueryEndpointExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmDeleteQueryEndpoint.expectations = append(mmDeleteQueryEndpoint.expectations, expectation) return expectation @@ -3703,6 +4417,7 @@ func (mmDeleteQueryEndpoint *mClientMockDeleteQueryEndpoint) Times(n uint64) *mC mmDeleteQueryEndpoint.mock.t.Fatalf("Times of ClientMock.DeleteQueryEndpoint mock can not be zero") } mm_atomic.StoreUint64(&mmDeleteQueryEndpoint.expectedInvocations, n) + mmDeleteQueryEndpoint.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmDeleteQueryEndpoint } @@ -3722,6 +4437,8 @@ func (mmDeleteQueryEndpoint *ClientMock) DeleteQueryEndpoint(ctx context.Context mm_atomic.AddUint64(&mmDeleteQueryEndpoint.beforeDeleteQueryEndpointCounter, 1) defer mm_atomic.AddUint64(&mmDeleteQueryEndpoint.afterDeleteQueryEndpointCounter, 1) + mmDeleteQueryEndpoint.t.Helper() + if mmDeleteQueryEndpoint.inspectFuncDeleteQueryEndpoint != nil { mmDeleteQueryEndpoint.inspectFuncDeleteQueryEndpoint(ctx, serviceID) } @@ -3750,15 +4467,18 @@ func (mmDeleteQueryEndpoint *ClientMock) DeleteQueryEndpoint(ctx context.Context if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteQueryEndpoint.t.Errorf("ClientMock.DeleteQueryEndpoint got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteQueryEndpoint.t.Errorf("ClientMock.DeleteQueryEndpoint got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteQueryEndpoint.DeleteQueryEndpointMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmDeleteQueryEndpoint.t.Errorf("ClientMock.DeleteQueryEndpoint got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmDeleteQueryEndpoint.t.Errorf("ClientMock.DeleteQueryEndpoint got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteQueryEndpoint.DeleteQueryEndpointMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteQueryEndpoint.t.Errorf("ClientMock.DeleteQueryEndpoint got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteQueryEndpoint.t.Errorf("ClientMock.DeleteQueryEndpoint got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteQueryEndpoint.DeleteQueryEndpointMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmDeleteQueryEndpoint.DeleteQueryEndpointMock.defaultExpectation.results @@ -3818,7 +4538,7 @@ func (m *ClientMock) MinimockDeleteQueryEndpointDone() bool { func (m *ClientMock) MinimockDeleteQueryEndpointInspect() { for _, e := range m.DeleteQueryEndpointMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.DeleteQueryEndpoint with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.DeleteQueryEndpoint at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -3826,68 +4546,452 @@ func (m *ClientMock) MinimockDeleteQueryEndpointInspect() { // if default expectation was set then invocations count should be greater than zero if m.DeleteQueryEndpointMock.defaultExpectation != nil && afterDeleteQueryEndpointCounter < 1 { if m.DeleteQueryEndpointMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.DeleteQueryEndpoint") + m.t.Errorf("Expected call to ClientMock.DeleteQueryEndpoint at\n%s", m.DeleteQueryEndpointMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.DeleteQueryEndpoint with params: %#v", *m.DeleteQueryEndpointMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.DeleteQueryEndpoint at\n%s with params: %#v", m.DeleteQueryEndpointMock.defaultExpectation.expectationOrigins.origin, *m.DeleteQueryEndpointMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcDeleteQueryEndpoint != nil && afterDeleteQueryEndpointCounter < 1 { - m.t.Error("Expected call to ClientMock.DeleteQueryEndpoint") + m.t.Errorf("Expected call to ClientMock.DeleteQueryEndpoint at\n%s", m.funcDeleteQueryEndpointOrigin) } if !m.DeleteQueryEndpointMock.invocationsDone() && afterDeleteQueryEndpointCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.DeleteQueryEndpoint but found %d calls", - mm_atomic.LoadUint64(&m.DeleteQueryEndpointMock.expectedInvocations), afterDeleteQueryEndpointCounter) + m.t.Errorf("Expected %d calls to ClientMock.DeleteQueryEndpoint at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteQueryEndpointMock.expectedInvocations), m.DeleteQueryEndpointMock.expectedInvocationsOrigin, afterDeleteQueryEndpointCounter) } } -type mClientMockDeleteRole struct { +type mClientMockDeleteReversePrivateEndpoint struct { optional bool mock *ClientMock - defaultExpectation *ClientMockDeleteRoleExpectation - expectations []*ClientMockDeleteRoleExpectation + defaultExpectation *ClientMockDeleteReversePrivateEndpointExpectation + expectations []*ClientMockDeleteReversePrivateEndpointExpectation - callArgs []*ClientMockDeleteRoleParams + callArgs []*ClientMockDeleteReversePrivateEndpointParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } -// ClientMockDeleteRoleExpectation specifies expectation struct of the Client.DeleteRole -type ClientMockDeleteRoleExpectation struct { - mock *ClientMock - params *ClientMockDeleteRoleParams - paramPtrs *ClientMockDeleteRoleParamPtrs - results *ClientMockDeleteRoleResults - Counter uint64 +// ClientMockDeleteReversePrivateEndpointExpectation specifies expectation struct of the Client.DeleteReversePrivateEndpoint +type ClientMockDeleteReversePrivateEndpointExpectation struct { + mock *ClientMock + params *ClientMockDeleteReversePrivateEndpointParams + paramPtrs *ClientMockDeleteReversePrivateEndpointParamPtrs + expectationOrigins ClientMockDeleteReversePrivateEndpointExpectationOrigins + results *ClientMockDeleteReversePrivateEndpointResults + returnOrigin string + Counter uint64 } -// ClientMockDeleteRoleParams contains parameters of the Client.DeleteRole -type ClientMockDeleteRoleParams struct { - ctx context.Context - serviceID string - name string +// ClientMockDeleteReversePrivateEndpointParams contains parameters of the Client.DeleteReversePrivateEndpoint +type ClientMockDeleteReversePrivateEndpointParams struct { + ctx context.Context + serviceId string + reversePrivateEndpointId string } -// ClientMockDeleteRoleParamPtrs contains pointers to parameters of the Client.DeleteRole -type ClientMockDeleteRoleParamPtrs struct { - ctx *context.Context - serviceID *string - name *string +// ClientMockDeleteReversePrivateEndpointParamPtrs contains pointers to parameters of the Client.DeleteReversePrivateEndpoint +type ClientMockDeleteReversePrivateEndpointParamPtrs struct { + ctx *context.Context + serviceId *string + reversePrivateEndpointId *string } -// ClientMockDeleteRoleResults contains results of the Client.DeleteRole -type ClientMockDeleteRoleResults struct { +// ClientMockDeleteReversePrivateEndpointResults contains results of the Client.DeleteReversePrivateEndpoint +type ClientMockDeleteReversePrivateEndpointResults struct { err error } +// ClientMockDeleteReversePrivateEndpointOrigins contains origins of expectations of the Client.DeleteReversePrivateEndpoint +type ClientMockDeleteReversePrivateEndpointExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originReversePrivateEndpointId string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. // It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to // catch the problems when the expected method call is totally skipped during test run. -func (mmDeleteRole *mClientMockDeleteRole) Optional() *mClientMockDeleteRole { +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) Optional() *mClientMockDeleteReversePrivateEndpoint { + mmDeleteReversePrivateEndpoint.optional = true + return mmDeleteReversePrivateEndpoint +} + +// Expect sets up expected params for Client.DeleteReversePrivateEndpoint +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) Expect(ctx context.Context, serviceId string, reversePrivateEndpointId string) *mClientMockDeleteReversePrivateEndpoint { + if mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpoint != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Set") + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation == nil { + mmDeleteReversePrivateEndpoint.defaultExpectation = &ClientMockDeleteReversePrivateEndpointExpectation{} + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by ExpectParams functions") + } + + mmDeleteReversePrivateEndpoint.defaultExpectation.params = &ClientMockDeleteReversePrivateEndpointParams{ctx, serviceId, reversePrivateEndpointId} + mmDeleteReversePrivateEndpoint.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmDeleteReversePrivateEndpoint.expectations { + if minimock.Equal(e.params, mmDeleteReversePrivateEndpoint.defaultExpectation.params) { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteReversePrivateEndpoint.defaultExpectation.params) + } + } + + return mmDeleteReversePrivateEndpoint +} + +// ExpectCtxParam1 sets up expected param ctx for Client.DeleteReversePrivateEndpoint +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) ExpectCtxParam1(ctx context.Context) *mClientMockDeleteReversePrivateEndpoint { + if mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpoint != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Set") + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation == nil { + mmDeleteReversePrivateEndpoint.defaultExpectation = &ClientMockDeleteReversePrivateEndpointExpectation{} + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation.params != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Expect") + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockDeleteReversePrivateEndpointParamPtrs{} + } + mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteReversePrivateEndpoint.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmDeleteReversePrivateEndpoint +} + +// ExpectServiceIdParam2 sets up expected param serviceId for Client.DeleteReversePrivateEndpoint +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) ExpectServiceIdParam2(serviceId string) *mClientMockDeleteReversePrivateEndpoint { + if mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpoint != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Set") + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation == nil { + mmDeleteReversePrivateEndpoint.defaultExpectation = &ClientMockDeleteReversePrivateEndpointExpectation{} + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation.params != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Expect") + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockDeleteReversePrivateEndpointParamPtrs{} + } + mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs.serviceId = &serviceId + mmDeleteReversePrivateEndpoint.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) + + return mmDeleteReversePrivateEndpoint +} + +// ExpectReversePrivateEndpointIdParam3 sets up expected param reversePrivateEndpointId for Client.DeleteReversePrivateEndpoint +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) ExpectReversePrivateEndpointIdParam3(reversePrivateEndpointId string) *mClientMockDeleteReversePrivateEndpoint { + if mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpoint != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Set") + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation == nil { + mmDeleteReversePrivateEndpoint.defaultExpectation = &ClientMockDeleteReversePrivateEndpointExpectation{} + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation.params != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Expect") + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockDeleteReversePrivateEndpointParamPtrs{} + } + mmDeleteReversePrivateEndpoint.defaultExpectation.paramPtrs.reversePrivateEndpointId = &reversePrivateEndpointId + mmDeleteReversePrivateEndpoint.defaultExpectation.expectationOrigins.originReversePrivateEndpointId = minimock.CallerInfo(1) + + return mmDeleteReversePrivateEndpoint +} + +// Inspect accepts an inspector function that has same arguments as the Client.DeleteReversePrivateEndpoint +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) Inspect(f func(ctx context.Context, serviceId string, reversePrivateEndpointId string)) *mClientMockDeleteReversePrivateEndpoint { + if mmDeleteReversePrivateEndpoint.mock.inspectFuncDeleteReversePrivateEndpoint != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("Inspect function is already set for ClientMock.DeleteReversePrivateEndpoint") + } + + mmDeleteReversePrivateEndpoint.mock.inspectFuncDeleteReversePrivateEndpoint = f + + return mmDeleteReversePrivateEndpoint +} + +// Return sets up results that will be returned by Client.DeleteReversePrivateEndpoint +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) Return(err error) *ClientMock { + if mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpoint != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Set") + } + + if mmDeleteReversePrivateEndpoint.defaultExpectation == nil { + mmDeleteReversePrivateEndpoint.defaultExpectation = &ClientMockDeleteReversePrivateEndpointExpectation{mock: mmDeleteReversePrivateEndpoint.mock} + } + mmDeleteReversePrivateEndpoint.defaultExpectation.results = &ClientMockDeleteReversePrivateEndpointResults{err} + mmDeleteReversePrivateEndpoint.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmDeleteReversePrivateEndpoint.mock +} + +// Set uses given function f to mock the Client.DeleteReversePrivateEndpoint method +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) Set(f func(ctx context.Context, serviceId string, reversePrivateEndpointId string) (err error)) *ClientMock { + if mmDeleteReversePrivateEndpoint.defaultExpectation != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("Default expectation is already set for the Client.DeleteReversePrivateEndpoint method") + } + + if len(mmDeleteReversePrivateEndpoint.expectations) > 0 { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("Some expectations are already set for the Client.DeleteReversePrivateEndpoint method") + } + + mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpoint = f + mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpointOrigin = minimock.CallerInfo(1) + return mmDeleteReversePrivateEndpoint.mock +} + +// When sets expectation for the Client.DeleteReversePrivateEndpoint which will trigger the result defined by the following +// Then helper +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) When(ctx context.Context, serviceId string, reversePrivateEndpointId string) *ClientMockDeleteReversePrivateEndpointExpectation { + if mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpoint != nil { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("ClientMock.DeleteReversePrivateEndpoint mock is already set by Set") + } + + expectation := &ClientMockDeleteReversePrivateEndpointExpectation{ + mock: mmDeleteReversePrivateEndpoint.mock, + params: &ClientMockDeleteReversePrivateEndpointParams{ctx, serviceId, reversePrivateEndpointId}, + expectationOrigins: ClientMockDeleteReversePrivateEndpointExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmDeleteReversePrivateEndpoint.expectations = append(mmDeleteReversePrivateEndpoint.expectations, expectation) + return expectation +} + +// Then sets up Client.DeleteReversePrivateEndpoint return parameters for the expectation previously defined by the When method +func (e *ClientMockDeleteReversePrivateEndpointExpectation) Then(err error) *ClientMock { + e.results = &ClientMockDeleteReversePrivateEndpointResults{err} + return e.mock +} + +// Times sets number of times Client.DeleteReversePrivateEndpoint should be invoked +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) Times(n uint64) *mClientMockDeleteReversePrivateEndpoint { + if n == 0 { + mmDeleteReversePrivateEndpoint.mock.t.Fatalf("Times of ClientMock.DeleteReversePrivateEndpoint mock can not be zero") + } + mm_atomic.StoreUint64(&mmDeleteReversePrivateEndpoint.expectedInvocations, n) + mmDeleteReversePrivateEndpoint.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmDeleteReversePrivateEndpoint +} + +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) invocationsDone() bool { + if len(mmDeleteReversePrivateEndpoint.expectations) == 0 && mmDeleteReversePrivateEndpoint.defaultExpectation == nil && mmDeleteReversePrivateEndpoint.mock.funcDeleteReversePrivateEndpoint == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmDeleteReversePrivateEndpoint.mock.afterDeleteReversePrivateEndpointCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmDeleteReversePrivateEndpoint.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// DeleteReversePrivateEndpoint implements Client +func (mmDeleteReversePrivateEndpoint *ClientMock) DeleteReversePrivateEndpoint(ctx context.Context, serviceId string, reversePrivateEndpointId string) (err error) { + mm_atomic.AddUint64(&mmDeleteReversePrivateEndpoint.beforeDeleteReversePrivateEndpointCounter, 1) + defer mm_atomic.AddUint64(&mmDeleteReversePrivateEndpoint.afterDeleteReversePrivateEndpointCounter, 1) + + mmDeleteReversePrivateEndpoint.t.Helper() + + if mmDeleteReversePrivateEndpoint.inspectFuncDeleteReversePrivateEndpoint != nil { + mmDeleteReversePrivateEndpoint.inspectFuncDeleteReversePrivateEndpoint(ctx, serviceId, reversePrivateEndpointId) + } + + mm_params := ClientMockDeleteReversePrivateEndpointParams{ctx, serviceId, reversePrivateEndpointId} + + // Record call args + mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.mutex.Lock() + mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.callArgs = append(mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.callArgs, &mm_params) + mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.mutex.Unlock() + + for _, e := range mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.err + } + } + + if mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation.Counter, 1) + mm_want := mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation.params + mm_want_ptrs := mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation.paramPtrs + + mm_got := ClientMockDeleteReversePrivateEndpointParams{ctx, serviceId, reversePrivateEndpointId} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmDeleteReversePrivateEndpoint.t.Errorf("ClientMock.DeleteReversePrivateEndpoint got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { + mmDeleteReversePrivateEndpoint.t.Errorf("ClientMock.DeleteReversePrivateEndpoint got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + } + + if mm_want_ptrs.reversePrivateEndpointId != nil && !minimock.Equal(*mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId) { + mmDeleteReversePrivateEndpoint.t.Errorf("ClientMock.DeleteReversePrivateEndpoint got unexpected parameter reversePrivateEndpointId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originReversePrivateEndpointId, *mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId, minimock.Diff(*mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmDeleteReversePrivateEndpoint.t.Errorf("ClientMock.DeleteReversePrivateEndpoint got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmDeleteReversePrivateEndpoint.DeleteReversePrivateEndpointMock.defaultExpectation.results + if mm_results == nil { + mmDeleteReversePrivateEndpoint.t.Fatal("No results are set for the ClientMock.DeleteReversePrivateEndpoint") + } + return (*mm_results).err + } + if mmDeleteReversePrivateEndpoint.funcDeleteReversePrivateEndpoint != nil { + return mmDeleteReversePrivateEndpoint.funcDeleteReversePrivateEndpoint(ctx, serviceId, reversePrivateEndpointId) + } + mmDeleteReversePrivateEndpoint.t.Fatalf("Unexpected call to ClientMock.DeleteReversePrivateEndpoint. %v %v %v", ctx, serviceId, reversePrivateEndpointId) + return +} + +// DeleteReversePrivateEndpointAfterCounter returns a count of finished ClientMock.DeleteReversePrivateEndpoint invocations +func (mmDeleteReversePrivateEndpoint *ClientMock) DeleteReversePrivateEndpointAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteReversePrivateEndpoint.afterDeleteReversePrivateEndpointCounter) +} + +// DeleteReversePrivateEndpointBeforeCounter returns a count of ClientMock.DeleteReversePrivateEndpoint invocations +func (mmDeleteReversePrivateEndpoint *ClientMock) DeleteReversePrivateEndpointBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmDeleteReversePrivateEndpoint.beforeDeleteReversePrivateEndpointCounter) +} + +// Calls returns a list of arguments used in each call to ClientMock.DeleteReversePrivateEndpoint. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmDeleteReversePrivateEndpoint *mClientMockDeleteReversePrivateEndpoint) Calls() []*ClientMockDeleteReversePrivateEndpointParams { + mmDeleteReversePrivateEndpoint.mutex.RLock() + + argCopy := make([]*ClientMockDeleteReversePrivateEndpointParams, len(mmDeleteReversePrivateEndpoint.callArgs)) + copy(argCopy, mmDeleteReversePrivateEndpoint.callArgs) + + mmDeleteReversePrivateEndpoint.mutex.RUnlock() + + return argCopy +} + +// MinimockDeleteReversePrivateEndpointDone returns true if the count of the DeleteReversePrivateEndpoint invocations corresponds +// the number of defined expectations +func (m *ClientMock) MinimockDeleteReversePrivateEndpointDone() bool { + if m.DeleteReversePrivateEndpointMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.DeleteReversePrivateEndpointMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.DeleteReversePrivateEndpointMock.invocationsDone() +} + +// MinimockDeleteReversePrivateEndpointInspect logs each unmet expectation +func (m *ClientMock) MinimockDeleteReversePrivateEndpointInspect() { + for _, e := range m.DeleteReversePrivateEndpointMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to ClientMock.DeleteReversePrivateEndpoint at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterDeleteReversePrivateEndpointCounter := mm_atomic.LoadUint64(&m.afterDeleteReversePrivateEndpointCounter) + // if default expectation was set then invocations count should be greater than zero + if m.DeleteReversePrivateEndpointMock.defaultExpectation != nil && afterDeleteReversePrivateEndpointCounter < 1 { + if m.DeleteReversePrivateEndpointMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to ClientMock.DeleteReversePrivateEndpoint at\n%s", m.DeleteReversePrivateEndpointMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to ClientMock.DeleteReversePrivateEndpoint at\n%s with params: %#v", m.DeleteReversePrivateEndpointMock.defaultExpectation.expectationOrigins.origin, *m.DeleteReversePrivateEndpointMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcDeleteReversePrivateEndpoint != nil && afterDeleteReversePrivateEndpointCounter < 1 { + m.t.Errorf("Expected call to ClientMock.DeleteReversePrivateEndpoint at\n%s", m.funcDeleteReversePrivateEndpointOrigin) + } + + if !m.DeleteReversePrivateEndpointMock.invocationsDone() && afterDeleteReversePrivateEndpointCounter > 0 { + m.t.Errorf("Expected %d calls to ClientMock.DeleteReversePrivateEndpoint at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteReversePrivateEndpointMock.expectedInvocations), m.DeleteReversePrivateEndpointMock.expectedInvocationsOrigin, afterDeleteReversePrivateEndpointCounter) + } +} + +type mClientMockDeleteRole struct { + optional bool + mock *ClientMock + defaultExpectation *ClientMockDeleteRoleExpectation + expectations []*ClientMockDeleteRoleExpectation + + callArgs []*ClientMockDeleteRoleParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// ClientMockDeleteRoleExpectation specifies expectation struct of the Client.DeleteRole +type ClientMockDeleteRoleExpectation struct { + mock *ClientMock + params *ClientMockDeleteRoleParams + paramPtrs *ClientMockDeleteRoleParamPtrs + expectationOrigins ClientMockDeleteRoleExpectationOrigins + results *ClientMockDeleteRoleResults + returnOrigin string + Counter uint64 +} + +// ClientMockDeleteRoleParams contains parameters of the Client.DeleteRole +type ClientMockDeleteRoleParams struct { + ctx context.Context + serviceID string + name string +} + +// ClientMockDeleteRoleParamPtrs contains pointers to parameters of the Client.DeleteRole +type ClientMockDeleteRoleParamPtrs struct { + ctx *context.Context + serviceID *string + name *string +} + +// ClientMockDeleteRoleResults contains results of the Client.DeleteRole +type ClientMockDeleteRoleResults struct { + err error +} + +// ClientMockDeleteRoleOrigins contains origins of expectations of the Client.DeleteRole +type ClientMockDeleteRoleExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originName string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmDeleteRole *mClientMockDeleteRole) Optional() *mClientMockDeleteRole { mmDeleteRole.optional = true return mmDeleteRole } @@ -3907,6 +5011,7 @@ func (mmDeleteRole *mClientMockDeleteRole) Expect(ctx context.Context, serviceID } mmDeleteRole.defaultExpectation.params = &ClientMockDeleteRoleParams{ctx, serviceID, name} + mmDeleteRole.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmDeleteRole.expectations { if minimock.Equal(e.params, mmDeleteRole.defaultExpectation.params) { mmDeleteRole.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteRole.defaultExpectation.params) @@ -3934,6 +5039,7 @@ func (mmDeleteRole *mClientMockDeleteRole) ExpectCtxParam1(ctx context.Context) mmDeleteRole.defaultExpectation.paramPtrs = &ClientMockDeleteRoleParamPtrs{} } mmDeleteRole.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteRole.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmDeleteRole } @@ -3956,6 +5062,7 @@ func (mmDeleteRole *mClientMockDeleteRole) ExpectServiceIDParam2(serviceID strin mmDeleteRole.defaultExpectation.paramPtrs = &ClientMockDeleteRoleParamPtrs{} } mmDeleteRole.defaultExpectation.paramPtrs.serviceID = &serviceID + mmDeleteRole.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmDeleteRole } @@ -3978,6 +5085,7 @@ func (mmDeleteRole *mClientMockDeleteRole) ExpectNameParam3(name string) *mClien mmDeleteRole.defaultExpectation.paramPtrs = &ClientMockDeleteRoleParamPtrs{} } mmDeleteRole.defaultExpectation.paramPtrs.name = &name + mmDeleteRole.defaultExpectation.expectationOrigins.originName = minimock.CallerInfo(1) return mmDeleteRole } @@ -4003,6 +5111,7 @@ func (mmDeleteRole *mClientMockDeleteRole) Return(err error) *ClientMock { mmDeleteRole.defaultExpectation = &ClientMockDeleteRoleExpectation{mock: mmDeleteRole.mock} } mmDeleteRole.defaultExpectation.results = &ClientMockDeleteRoleResults{err} + mmDeleteRole.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmDeleteRole.mock } @@ -4017,6 +5126,7 @@ func (mmDeleteRole *mClientMockDeleteRole) Set(f func(ctx context.Context, servi } mmDeleteRole.mock.funcDeleteRole = f + mmDeleteRole.mock.funcDeleteRoleOrigin = minimock.CallerInfo(1) return mmDeleteRole.mock } @@ -4028,8 +5138,9 @@ func (mmDeleteRole *mClientMockDeleteRole) When(ctx context.Context, serviceID s } expectation := &ClientMockDeleteRoleExpectation{ - mock: mmDeleteRole.mock, - params: &ClientMockDeleteRoleParams{ctx, serviceID, name}, + mock: mmDeleteRole.mock, + params: &ClientMockDeleteRoleParams{ctx, serviceID, name}, + expectationOrigins: ClientMockDeleteRoleExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmDeleteRole.expectations = append(mmDeleteRole.expectations, expectation) return expectation @@ -4047,6 +5158,7 @@ func (mmDeleteRole *mClientMockDeleteRole) Times(n uint64) *mClientMockDeleteRol mmDeleteRole.mock.t.Fatalf("Times of ClientMock.DeleteRole mock can not be zero") } mm_atomic.StoreUint64(&mmDeleteRole.expectedInvocations, n) + mmDeleteRole.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmDeleteRole } @@ -4066,6 +5178,8 @@ func (mmDeleteRole *ClientMock) DeleteRole(ctx context.Context, serviceID string mm_atomic.AddUint64(&mmDeleteRole.beforeDeleteRoleCounter, 1) defer mm_atomic.AddUint64(&mmDeleteRole.afterDeleteRoleCounter, 1) + mmDeleteRole.t.Helper() + if mmDeleteRole.inspectFuncDeleteRole != nil { mmDeleteRole.inspectFuncDeleteRole(ctx, serviceID, name) } @@ -4094,19 +5208,23 @@ func (mmDeleteRole *ClientMock) DeleteRole(ctx context.Context, serviceID string if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteRole.t.Errorf("ClientMock.DeleteRole got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteRole.t.Errorf("ClientMock.DeleteRole got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRole.DeleteRoleMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmDeleteRole.t.Errorf("ClientMock.DeleteRole got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmDeleteRole.t.Errorf("ClientMock.DeleteRole got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRole.DeleteRoleMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.name != nil && !minimock.Equal(*mm_want_ptrs.name, mm_got.name) { - mmDeleteRole.t.Errorf("ClientMock.DeleteRole got unexpected parameter name, want: %#v, got: %#v%s\n", *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) + mmDeleteRole.t.Errorf("ClientMock.DeleteRole got unexpected parameter name, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRole.DeleteRoleMock.defaultExpectation.expectationOrigins.originName, *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteRole.t.Errorf("ClientMock.DeleteRole got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteRole.t.Errorf("ClientMock.DeleteRole got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteRole.DeleteRoleMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmDeleteRole.DeleteRoleMock.defaultExpectation.results @@ -4166,7 +5284,7 @@ func (m *ClientMock) MinimockDeleteRoleDone() bool { func (m *ClientMock) MinimockDeleteRoleInspect() { for _, e := range m.DeleteRoleMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.DeleteRole with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.DeleteRole at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -4174,19 +5292,19 @@ func (m *ClientMock) MinimockDeleteRoleInspect() { // if default expectation was set then invocations count should be greater than zero if m.DeleteRoleMock.defaultExpectation != nil && afterDeleteRoleCounter < 1 { if m.DeleteRoleMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.DeleteRole") + m.t.Errorf("Expected call to ClientMock.DeleteRole at\n%s", m.DeleteRoleMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.DeleteRole with params: %#v", *m.DeleteRoleMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.DeleteRole at\n%s with params: %#v", m.DeleteRoleMock.defaultExpectation.expectationOrigins.origin, *m.DeleteRoleMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcDeleteRole != nil && afterDeleteRoleCounter < 1 { - m.t.Error("Expected call to ClientMock.DeleteRole") + m.t.Errorf("Expected call to ClientMock.DeleteRole at\n%s", m.funcDeleteRoleOrigin) } if !m.DeleteRoleMock.invocationsDone() && afterDeleteRoleCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.DeleteRole but found %d calls", - mm_atomic.LoadUint64(&m.DeleteRoleMock.expectedInvocations), afterDeleteRoleCounter) + m.t.Errorf("Expected %d calls to ClientMock.DeleteRole at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteRoleMock.expectedInvocations), m.DeleteRoleMock.expectedInvocationsOrigin, afterDeleteRoleCounter) } } @@ -4199,16 +5317,19 @@ type mClientMockDeleteService struct { callArgs []*ClientMockDeleteServiceParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockDeleteServiceExpectation specifies expectation struct of the Client.DeleteService type ClientMockDeleteServiceExpectation struct { - mock *ClientMock - params *ClientMockDeleteServiceParams - paramPtrs *ClientMockDeleteServiceParamPtrs - results *ClientMockDeleteServiceResults - Counter uint64 + mock *ClientMock + params *ClientMockDeleteServiceParams + paramPtrs *ClientMockDeleteServiceParamPtrs + expectationOrigins ClientMockDeleteServiceExpectationOrigins + results *ClientMockDeleteServiceResults + returnOrigin string + Counter uint64 } // ClientMockDeleteServiceParams contains parameters of the Client.DeleteService @@ -4229,6 +5350,13 @@ type ClientMockDeleteServiceResults struct { err error } +// ClientMockDeleteServiceOrigins contains origins of expectations of the Client.DeleteService +type ClientMockDeleteServiceExpectationOrigins struct { + origin string + originCtx string + originServiceId string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -4254,6 +5382,7 @@ func (mmDeleteService *mClientMockDeleteService) Expect(ctx context.Context, ser } mmDeleteService.defaultExpectation.params = &ClientMockDeleteServiceParams{ctx, serviceId} + mmDeleteService.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmDeleteService.expectations { if minimock.Equal(e.params, mmDeleteService.defaultExpectation.params) { mmDeleteService.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteService.defaultExpectation.params) @@ -4281,6 +5410,7 @@ func (mmDeleteService *mClientMockDeleteService) ExpectCtxParam1(ctx context.Con mmDeleteService.defaultExpectation.paramPtrs = &ClientMockDeleteServiceParamPtrs{} } mmDeleteService.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteService.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmDeleteService } @@ -4303,6 +5433,7 @@ func (mmDeleteService *mClientMockDeleteService) ExpectServiceIdParam2(serviceId mmDeleteService.defaultExpectation.paramPtrs = &ClientMockDeleteServiceParamPtrs{} } mmDeleteService.defaultExpectation.paramPtrs.serviceId = &serviceId + mmDeleteService.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmDeleteService } @@ -4328,6 +5459,7 @@ func (mmDeleteService *mClientMockDeleteService) Return(sp1 *Service, err error) mmDeleteService.defaultExpectation = &ClientMockDeleteServiceExpectation{mock: mmDeleteService.mock} } mmDeleteService.defaultExpectation.results = &ClientMockDeleteServiceResults{sp1, err} + mmDeleteService.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmDeleteService.mock } @@ -4342,6 +5474,7 @@ func (mmDeleteService *mClientMockDeleteService) Set(f func(ctx context.Context, } mmDeleteService.mock.funcDeleteService = f + mmDeleteService.mock.funcDeleteServiceOrigin = minimock.CallerInfo(1) return mmDeleteService.mock } @@ -4353,8 +5486,9 @@ func (mmDeleteService *mClientMockDeleteService) When(ctx context.Context, servi } expectation := &ClientMockDeleteServiceExpectation{ - mock: mmDeleteService.mock, - params: &ClientMockDeleteServiceParams{ctx, serviceId}, + mock: mmDeleteService.mock, + params: &ClientMockDeleteServiceParams{ctx, serviceId}, + expectationOrigins: ClientMockDeleteServiceExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmDeleteService.expectations = append(mmDeleteService.expectations, expectation) return expectation @@ -4372,6 +5506,7 @@ func (mmDeleteService *mClientMockDeleteService) Times(n uint64) *mClientMockDel mmDeleteService.mock.t.Fatalf("Times of ClientMock.DeleteService mock can not be zero") } mm_atomic.StoreUint64(&mmDeleteService.expectedInvocations, n) + mmDeleteService.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmDeleteService } @@ -4391,6 +5526,8 @@ func (mmDeleteService *ClientMock) DeleteService(ctx context.Context, serviceId mm_atomic.AddUint64(&mmDeleteService.beforeDeleteServiceCounter, 1) defer mm_atomic.AddUint64(&mmDeleteService.afterDeleteServiceCounter, 1) + mmDeleteService.t.Helper() + if mmDeleteService.inspectFuncDeleteService != nil { mmDeleteService.inspectFuncDeleteService(ctx, serviceId) } @@ -4419,15 +5556,18 @@ func (mmDeleteService *ClientMock) DeleteService(ctx context.Context, serviceId if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteService.t.Errorf("ClientMock.DeleteService got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteService.t.Errorf("ClientMock.DeleteService got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteService.DeleteServiceMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmDeleteService.t.Errorf("ClientMock.DeleteService got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmDeleteService.t.Errorf("ClientMock.DeleteService got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteService.DeleteServiceMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteService.t.Errorf("ClientMock.DeleteService got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteService.t.Errorf("ClientMock.DeleteService got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteService.DeleteServiceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmDeleteService.DeleteServiceMock.defaultExpectation.results @@ -4487,7 +5627,7 @@ func (m *ClientMock) MinimockDeleteServiceDone() bool { func (m *ClientMock) MinimockDeleteServiceInspect() { for _, e := range m.DeleteServiceMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.DeleteService with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.DeleteService at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -4495,19 +5635,19 @@ func (m *ClientMock) MinimockDeleteServiceInspect() { // if default expectation was set then invocations count should be greater than zero if m.DeleteServiceMock.defaultExpectation != nil && afterDeleteServiceCounter < 1 { if m.DeleteServiceMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.DeleteService") + m.t.Errorf("Expected call to ClientMock.DeleteService at\n%s", m.DeleteServiceMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.DeleteService with params: %#v", *m.DeleteServiceMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.DeleteService at\n%s with params: %#v", m.DeleteServiceMock.defaultExpectation.expectationOrigins.origin, *m.DeleteServiceMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcDeleteService != nil && afterDeleteServiceCounter < 1 { - m.t.Error("Expected call to ClientMock.DeleteService") + m.t.Errorf("Expected call to ClientMock.DeleteService at\n%s", m.funcDeleteServiceOrigin) } if !m.DeleteServiceMock.invocationsDone() && afterDeleteServiceCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.DeleteService but found %d calls", - mm_atomic.LoadUint64(&m.DeleteServiceMock.expectedInvocations), afterDeleteServiceCounter) + m.t.Errorf("Expected %d calls to ClientMock.DeleteService at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteServiceMock.expectedInvocations), m.DeleteServiceMock.expectedInvocationsOrigin, afterDeleteServiceCounter) } } @@ -4520,16 +5660,19 @@ type mClientMockDeleteUser struct { callArgs []*ClientMockDeleteUserParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockDeleteUserExpectation specifies expectation struct of the Client.DeleteUser type ClientMockDeleteUserExpectation struct { - mock *ClientMock - params *ClientMockDeleteUserParams - paramPtrs *ClientMockDeleteUserParamPtrs - results *ClientMockDeleteUserResults - Counter uint64 + mock *ClientMock + params *ClientMockDeleteUserParams + paramPtrs *ClientMockDeleteUserParamPtrs + expectationOrigins ClientMockDeleteUserExpectationOrigins + results *ClientMockDeleteUserResults + returnOrigin string + Counter uint64 } // ClientMockDeleteUserParams contains parameters of the Client.DeleteUser @@ -4551,6 +5694,14 @@ type ClientMockDeleteUserResults struct { err error } +// ClientMockDeleteUserOrigins contains origins of expectations of the Client.DeleteUser +type ClientMockDeleteUserExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -4576,6 +5727,7 @@ func (mmDeleteUser *mClientMockDeleteUser) Expect(ctx context.Context, serviceID } mmDeleteUser.defaultExpectation.params = &ClientMockDeleteUserParams{ctx, serviceID, name} + mmDeleteUser.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmDeleteUser.expectations { if minimock.Equal(e.params, mmDeleteUser.defaultExpectation.params) { mmDeleteUser.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeleteUser.defaultExpectation.params) @@ -4603,6 +5755,7 @@ func (mmDeleteUser *mClientMockDeleteUser) ExpectCtxParam1(ctx context.Context) mmDeleteUser.defaultExpectation.paramPtrs = &ClientMockDeleteUserParamPtrs{} } mmDeleteUser.defaultExpectation.paramPtrs.ctx = &ctx + mmDeleteUser.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmDeleteUser } @@ -4625,6 +5778,7 @@ func (mmDeleteUser *mClientMockDeleteUser) ExpectServiceIDParam2(serviceID strin mmDeleteUser.defaultExpectation.paramPtrs = &ClientMockDeleteUserParamPtrs{} } mmDeleteUser.defaultExpectation.paramPtrs.serviceID = &serviceID + mmDeleteUser.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmDeleteUser } @@ -4647,6 +5801,7 @@ func (mmDeleteUser *mClientMockDeleteUser) ExpectNameParam3(name string) *mClien mmDeleteUser.defaultExpectation.paramPtrs = &ClientMockDeleteUserParamPtrs{} } mmDeleteUser.defaultExpectation.paramPtrs.name = &name + mmDeleteUser.defaultExpectation.expectationOrigins.originName = minimock.CallerInfo(1) return mmDeleteUser } @@ -4672,6 +5827,7 @@ func (mmDeleteUser *mClientMockDeleteUser) Return(err error) *ClientMock { mmDeleteUser.defaultExpectation = &ClientMockDeleteUserExpectation{mock: mmDeleteUser.mock} } mmDeleteUser.defaultExpectation.results = &ClientMockDeleteUserResults{err} + mmDeleteUser.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmDeleteUser.mock } @@ -4686,6 +5842,7 @@ func (mmDeleteUser *mClientMockDeleteUser) Set(f func(ctx context.Context, servi } mmDeleteUser.mock.funcDeleteUser = f + mmDeleteUser.mock.funcDeleteUserOrigin = minimock.CallerInfo(1) return mmDeleteUser.mock } @@ -4697,8 +5854,9 @@ func (mmDeleteUser *mClientMockDeleteUser) When(ctx context.Context, serviceID s } expectation := &ClientMockDeleteUserExpectation{ - mock: mmDeleteUser.mock, - params: &ClientMockDeleteUserParams{ctx, serviceID, name}, + mock: mmDeleteUser.mock, + params: &ClientMockDeleteUserParams{ctx, serviceID, name}, + expectationOrigins: ClientMockDeleteUserExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmDeleteUser.expectations = append(mmDeleteUser.expectations, expectation) return expectation @@ -4716,6 +5874,7 @@ func (mmDeleteUser *mClientMockDeleteUser) Times(n uint64) *mClientMockDeleteUse mmDeleteUser.mock.t.Fatalf("Times of ClientMock.DeleteUser mock can not be zero") } mm_atomic.StoreUint64(&mmDeleteUser.expectedInvocations, n) + mmDeleteUser.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmDeleteUser } @@ -4735,6 +5894,8 @@ func (mmDeleteUser *ClientMock) DeleteUser(ctx context.Context, serviceID string mm_atomic.AddUint64(&mmDeleteUser.beforeDeleteUserCounter, 1) defer mm_atomic.AddUint64(&mmDeleteUser.afterDeleteUserCounter, 1) + mmDeleteUser.t.Helper() + if mmDeleteUser.inspectFuncDeleteUser != nil { mmDeleteUser.inspectFuncDeleteUser(ctx, serviceID, name) } @@ -4763,19 +5924,23 @@ func (mmDeleteUser *ClientMock) DeleteUser(ctx context.Context, serviceID string if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmDeleteUser.t.Errorf("ClientMock.DeleteUser got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmDeleteUser.t.Errorf("ClientMock.DeleteUser got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteUser.DeleteUserMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmDeleteUser.t.Errorf("ClientMock.DeleteUser got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmDeleteUser.t.Errorf("ClientMock.DeleteUser got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteUser.DeleteUserMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.name != nil && !minimock.Equal(*mm_want_ptrs.name, mm_got.name) { - mmDeleteUser.t.Errorf("ClientMock.DeleteUser got unexpected parameter name, want: %#v, got: %#v%s\n", *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) + mmDeleteUser.t.Errorf("ClientMock.DeleteUser got unexpected parameter name, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteUser.DeleteUserMock.defaultExpectation.expectationOrigins.originName, *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmDeleteUser.t.Errorf("ClientMock.DeleteUser got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmDeleteUser.t.Errorf("ClientMock.DeleteUser got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmDeleteUser.DeleteUserMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmDeleteUser.DeleteUserMock.defaultExpectation.results @@ -4835,7 +6000,7 @@ func (m *ClientMock) MinimockDeleteUserDone() bool { func (m *ClientMock) MinimockDeleteUserInspect() { for _, e := range m.DeleteUserMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.DeleteUser with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.DeleteUser at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -4843,19 +6008,19 @@ func (m *ClientMock) MinimockDeleteUserInspect() { // if default expectation was set then invocations count should be greater than zero if m.DeleteUserMock.defaultExpectation != nil && afterDeleteUserCounter < 1 { if m.DeleteUserMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.DeleteUser") + m.t.Errorf("Expected call to ClientMock.DeleteUser at\n%s", m.DeleteUserMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.DeleteUser with params: %#v", *m.DeleteUserMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.DeleteUser at\n%s with params: %#v", m.DeleteUserMock.defaultExpectation.expectationOrigins.origin, *m.DeleteUserMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcDeleteUser != nil && afterDeleteUserCounter < 1 { - m.t.Error("Expected call to ClientMock.DeleteUser") + m.t.Errorf("Expected call to ClientMock.DeleteUser at\n%s", m.funcDeleteUserOrigin) } if !m.DeleteUserMock.invocationsDone() && afterDeleteUserCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.DeleteUser but found %d calls", - mm_atomic.LoadUint64(&m.DeleteUserMock.expectedInvocations), afterDeleteUserCounter) + m.t.Errorf("Expected %d calls to ClientMock.DeleteUser at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.DeleteUserMock.expectedInvocations), m.DeleteUserMock.expectedInvocationsOrigin, afterDeleteUserCounter) } } @@ -4868,16 +6033,19 @@ type mClientMockGetApiKeyID struct { callArgs []*ClientMockGetApiKeyIDParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetApiKeyIDExpectation specifies expectation struct of the Client.GetApiKeyID type ClientMockGetApiKeyIDExpectation struct { - mock *ClientMock - params *ClientMockGetApiKeyIDParams - paramPtrs *ClientMockGetApiKeyIDParamPtrs - results *ClientMockGetApiKeyIDResults - Counter uint64 + mock *ClientMock + params *ClientMockGetApiKeyIDParams + paramPtrs *ClientMockGetApiKeyIDParamPtrs + expectationOrigins ClientMockGetApiKeyIDExpectationOrigins + results *ClientMockGetApiKeyIDResults + returnOrigin string + Counter uint64 } // ClientMockGetApiKeyIDParams contains parameters of the Client.GetApiKeyID @@ -4898,6 +6066,13 @@ type ClientMockGetApiKeyIDResults struct { err error } +// ClientMockGetApiKeyIDOrigins contains origins of expectations of the Client.GetApiKeyID +type ClientMockGetApiKeyIDExpectationOrigins struct { + origin string + originCtx string + originName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -4923,6 +6098,7 @@ func (mmGetApiKeyID *mClientMockGetApiKeyID) Expect(ctx context.Context, name *s } mmGetApiKeyID.defaultExpectation.params = &ClientMockGetApiKeyIDParams{ctx, name} + mmGetApiKeyID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetApiKeyID.expectations { if minimock.Equal(e.params, mmGetApiKeyID.defaultExpectation.params) { mmGetApiKeyID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetApiKeyID.defaultExpectation.params) @@ -4950,6 +6126,7 @@ func (mmGetApiKeyID *mClientMockGetApiKeyID) ExpectCtxParam1(ctx context.Context mmGetApiKeyID.defaultExpectation.paramPtrs = &ClientMockGetApiKeyIDParamPtrs{} } mmGetApiKeyID.defaultExpectation.paramPtrs.ctx = &ctx + mmGetApiKeyID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetApiKeyID } @@ -4972,6 +6149,7 @@ func (mmGetApiKeyID *mClientMockGetApiKeyID) ExpectNameParam2(name *string) *mCl mmGetApiKeyID.defaultExpectation.paramPtrs = &ClientMockGetApiKeyIDParamPtrs{} } mmGetApiKeyID.defaultExpectation.paramPtrs.name = &name + mmGetApiKeyID.defaultExpectation.expectationOrigins.originName = minimock.CallerInfo(1) return mmGetApiKeyID } @@ -4997,6 +6175,7 @@ func (mmGetApiKeyID *mClientMockGetApiKeyID) Return(ap1 *ApiKey, err error) *Cli mmGetApiKeyID.defaultExpectation = &ClientMockGetApiKeyIDExpectation{mock: mmGetApiKeyID.mock} } mmGetApiKeyID.defaultExpectation.results = &ClientMockGetApiKeyIDResults{ap1, err} + mmGetApiKeyID.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetApiKeyID.mock } @@ -5011,6 +6190,7 @@ func (mmGetApiKeyID *mClientMockGetApiKeyID) Set(f func(ctx context.Context, nam } mmGetApiKeyID.mock.funcGetApiKeyID = f + mmGetApiKeyID.mock.funcGetApiKeyIDOrigin = minimock.CallerInfo(1) return mmGetApiKeyID.mock } @@ -5022,8 +6202,9 @@ func (mmGetApiKeyID *mClientMockGetApiKeyID) When(ctx context.Context, name *str } expectation := &ClientMockGetApiKeyIDExpectation{ - mock: mmGetApiKeyID.mock, - params: &ClientMockGetApiKeyIDParams{ctx, name}, + mock: mmGetApiKeyID.mock, + params: &ClientMockGetApiKeyIDParams{ctx, name}, + expectationOrigins: ClientMockGetApiKeyIDExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetApiKeyID.expectations = append(mmGetApiKeyID.expectations, expectation) return expectation @@ -5041,6 +6222,7 @@ func (mmGetApiKeyID *mClientMockGetApiKeyID) Times(n uint64) *mClientMockGetApiK mmGetApiKeyID.mock.t.Fatalf("Times of ClientMock.GetApiKeyID mock can not be zero") } mm_atomic.StoreUint64(&mmGetApiKeyID.expectedInvocations, n) + mmGetApiKeyID.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetApiKeyID } @@ -5060,6 +6242,8 @@ func (mmGetApiKeyID *ClientMock) GetApiKeyID(ctx context.Context, name *string) mm_atomic.AddUint64(&mmGetApiKeyID.beforeGetApiKeyIDCounter, 1) defer mm_atomic.AddUint64(&mmGetApiKeyID.afterGetApiKeyIDCounter, 1) + mmGetApiKeyID.t.Helper() + if mmGetApiKeyID.inspectFuncGetApiKeyID != nil { mmGetApiKeyID.inspectFuncGetApiKeyID(ctx, name) } @@ -5088,15 +6272,18 @@ func (mmGetApiKeyID *ClientMock) GetApiKeyID(ctx context.Context, name *string) if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetApiKeyID.t.Errorf("ClientMock.GetApiKeyID got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetApiKeyID.t.Errorf("ClientMock.GetApiKeyID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetApiKeyID.GetApiKeyIDMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.name != nil && !minimock.Equal(*mm_want_ptrs.name, mm_got.name) { - mmGetApiKeyID.t.Errorf("ClientMock.GetApiKeyID got unexpected parameter name, want: %#v, got: %#v%s\n", *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) + mmGetApiKeyID.t.Errorf("ClientMock.GetApiKeyID got unexpected parameter name, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetApiKeyID.GetApiKeyIDMock.defaultExpectation.expectationOrigins.originName, *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetApiKeyID.t.Errorf("ClientMock.GetApiKeyID got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetApiKeyID.t.Errorf("ClientMock.GetApiKeyID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetApiKeyID.GetApiKeyIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetApiKeyID.GetApiKeyIDMock.defaultExpectation.results @@ -5156,7 +6343,7 @@ func (m *ClientMock) MinimockGetApiKeyIDDone() bool { func (m *ClientMock) MinimockGetApiKeyIDInspect() { for _, e := range m.GetApiKeyIDMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetApiKeyID with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetApiKeyID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -5164,19 +6351,19 @@ func (m *ClientMock) MinimockGetApiKeyIDInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetApiKeyIDMock.defaultExpectation != nil && afterGetApiKeyIDCounter < 1 { if m.GetApiKeyIDMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetApiKeyID") + m.t.Errorf("Expected call to ClientMock.GetApiKeyID at\n%s", m.GetApiKeyIDMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetApiKeyID with params: %#v", *m.GetApiKeyIDMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetApiKeyID at\n%s with params: %#v", m.GetApiKeyIDMock.defaultExpectation.expectationOrigins.origin, *m.GetApiKeyIDMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetApiKeyID != nil && afterGetApiKeyIDCounter < 1 { - m.t.Error("Expected call to ClientMock.GetApiKeyID") + m.t.Errorf("Expected call to ClientMock.GetApiKeyID at\n%s", m.funcGetApiKeyIDOrigin) } if !m.GetApiKeyIDMock.invocationsDone() && afterGetApiKeyIDCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetApiKeyID but found %d calls", - mm_atomic.LoadUint64(&m.GetApiKeyIDMock.expectedInvocations), afterGetApiKeyIDCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetApiKeyID at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetApiKeyIDMock.expectedInvocations), m.GetApiKeyIDMock.expectedInvocationsOrigin, afterGetApiKeyIDCounter) } } @@ -5189,16 +6376,19 @@ type mClientMockGetBackupConfiguration struct { callArgs []*ClientMockGetBackupConfigurationParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetBackupConfigurationExpectation specifies expectation struct of the Client.GetBackupConfiguration type ClientMockGetBackupConfigurationExpectation struct { - mock *ClientMock - params *ClientMockGetBackupConfigurationParams - paramPtrs *ClientMockGetBackupConfigurationParamPtrs - results *ClientMockGetBackupConfigurationResults - Counter uint64 + mock *ClientMock + params *ClientMockGetBackupConfigurationParams + paramPtrs *ClientMockGetBackupConfigurationParamPtrs + expectationOrigins ClientMockGetBackupConfigurationExpectationOrigins + results *ClientMockGetBackupConfigurationResults + returnOrigin string + Counter uint64 } // ClientMockGetBackupConfigurationParams contains parameters of the Client.GetBackupConfiguration @@ -5219,6 +6409,13 @@ type ClientMockGetBackupConfigurationResults struct { err error } +// ClientMockGetBackupConfigurationOrigins contains origins of expectations of the Client.GetBackupConfiguration +type ClientMockGetBackupConfigurationExpectationOrigins struct { + origin string + originCtx string + originServiceId string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -5244,6 +6441,7 @@ func (mmGetBackupConfiguration *mClientMockGetBackupConfiguration) Expect(ctx co } mmGetBackupConfiguration.defaultExpectation.params = &ClientMockGetBackupConfigurationParams{ctx, serviceId} + mmGetBackupConfiguration.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetBackupConfiguration.expectations { if minimock.Equal(e.params, mmGetBackupConfiguration.defaultExpectation.params) { mmGetBackupConfiguration.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetBackupConfiguration.defaultExpectation.params) @@ -5271,6 +6469,7 @@ func (mmGetBackupConfiguration *mClientMockGetBackupConfiguration) ExpectCtxPara mmGetBackupConfiguration.defaultExpectation.paramPtrs = &ClientMockGetBackupConfigurationParamPtrs{} } mmGetBackupConfiguration.defaultExpectation.paramPtrs.ctx = &ctx + mmGetBackupConfiguration.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetBackupConfiguration } @@ -5293,6 +6492,7 @@ func (mmGetBackupConfiguration *mClientMockGetBackupConfiguration) ExpectService mmGetBackupConfiguration.defaultExpectation.paramPtrs = &ClientMockGetBackupConfigurationParamPtrs{} } mmGetBackupConfiguration.defaultExpectation.paramPtrs.serviceId = &serviceId + mmGetBackupConfiguration.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmGetBackupConfiguration } @@ -5318,6 +6518,7 @@ func (mmGetBackupConfiguration *mClientMockGetBackupConfiguration) Return(bp1 *B mmGetBackupConfiguration.defaultExpectation = &ClientMockGetBackupConfigurationExpectation{mock: mmGetBackupConfiguration.mock} } mmGetBackupConfiguration.defaultExpectation.results = &ClientMockGetBackupConfigurationResults{bp1, err} + mmGetBackupConfiguration.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetBackupConfiguration.mock } @@ -5332,6 +6533,7 @@ func (mmGetBackupConfiguration *mClientMockGetBackupConfiguration) Set(f func(ct } mmGetBackupConfiguration.mock.funcGetBackupConfiguration = f + mmGetBackupConfiguration.mock.funcGetBackupConfigurationOrigin = minimock.CallerInfo(1) return mmGetBackupConfiguration.mock } @@ -5343,8 +6545,9 @@ func (mmGetBackupConfiguration *mClientMockGetBackupConfiguration) When(ctx cont } expectation := &ClientMockGetBackupConfigurationExpectation{ - mock: mmGetBackupConfiguration.mock, - params: &ClientMockGetBackupConfigurationParams{ctx, serviceId}, + mock: mmGetBackupConfiguration.mock, + params: &ClientMockGetBackupConfigurationParams{ctx, serviceId}, + expectationOrigins: ClientMockGetBackupConfigurationExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetBackupConfiguration.expectations = append(mmGetBackupConfiguration.expectations, expectation) return expectation @@ -5362,6 +6565,7 @@ func (mmGetBackupConfiguration *mClientMockGetBackupConfiguration) Times(n uint6 mmGetBackupConfiguration.mock.t.Fatalf("Times of ClientMock.GetBackupConfiguration mock can not be zero") } mm_atomic.StoreUint64(&mmGetBackupConfiguration.expectedInvocations, n) + mmGetBackupConfiguration.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetBackupConfiguration } @@ -5381,6 +6585,8 @@ func (mmGetBackupConfiguration *ClientMock) GetBackupConfiguration(ctx context.C mm_atomic.AddUint64(&mmGetBackupConfiguration.beforeGetBackupConfigurationCounter, 1) defer mm_atomic.AddUint64(&mmGetBackupConfiguration.afterGetBackupConfigurationCounter, 1) + mmGetBackupConfiguration.t.Helper() + if mmGetBackupConfiguration.inspectFuncGetBackupConfiguration != nil { mmGetBackupConfiguration.inspectFuncGetBackupConfiguration(ctx, serviceId) } @@ -5409,15 +6615,18 @@ func (mmGetBackupConfiguration *ClientMock) GetBackupConfiguration(ctx context.C if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetBackupConfiguration.t.Errorf("ClientMock.GetBackupConfiguration got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetBackupConfiguration.t.Errorf("ClientMock.GetBackupConfiguration got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetBackupConfiguration.GetBackupConfigurationMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmGetBackupConfiguration.t.Errorf("ClientMock.GetBackupConfiguration got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmGetBackupConfiguration.t.Errorf("ClientMock.GetBackupConfiguration got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetBackupConfiguration.GetBackupConfigurationMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetBackupConfiguration.t.Errorf("ClientMock.GetBackupConfiguration got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetBackupConfiguration.t.Errorf("ClientMock.GetBackupConfiguration got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetBackupConfiguration.GetBackupConfigurationMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetBackupConfiguration.GetBackupConfigurationMock.defaultExpectation.results @@ -5477,7 +6686,7 @@ func (m *ClientMock) MinimockGetBackupConfigurationDone() bool { func (m *ClientMock) MinimockGetBackupConfigurationInspect() { for _, e := range m.GetBackupConfigurationMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetBackupConfiguration with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetBackupConfiguration at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -5485,19 +6694,19 @@ func (m *ClientMock) MinimockGetBackupConfigurationInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetBackupConfigurationMock.defaultExpectation != nil && afterGetBackupConfigurationCounter < 1 { if m.GetBackupConfigurationMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetBackupConfiguration") + m.t.Errorf("Expected call to ClientMock.GetBackupConfiguration at\n%s", m.GetBackupConfigurationMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetBackupConfiguration with params: %#v", *m.GetBackupConfigurationMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetBackupConfiguration at\n%s with params: %#v", m.GetBackupConfigurationMock.defaultExpectation.expectationOrigins.origin, *m.GetBackupConfigurationMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetBackupConfiguration != nil && afterGetBackupConfigurationCounter < 1 { - m.t.Error("Expected call to ClientMock.GetBackupConfiguration") + m.t.Errorf("Expected call to ClientMock.GetBackupConfiguration at\n%s", m.funcGetBackupConfigurationOrigin) } if !m.GetBackupConfigurationMock.invocationsDone() && afterGetBackupConfigurationCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetBackupConfiguration but found %d calls", - mm_atomic.LoadUint64(&m.GetBackupConfigurationMock.expectedInvocations), afterGetBackupConfigurationCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetBackupConfiguration at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetBackupConfigurationMock.expectedInvocations), m.GetBackupConfigurationMock.expectedInvocationsOrigin, afterGetBackupConfigurationCounter) } } @@ -5510,16 +6719,19 @@ type mClientMockGetClickPipe struct { callArgs []*ClientMockGetClickPipeParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetClickPipeExpectation specifies expectation struct of the Client.GetClickPipe type ClientMockGetClickPipeExpectation struct { - mock *ClientMock - params *ClientMockGetClickPipeParams - paramPtrs *ClientMockGetClickPipeParamPtrs - results *ClientMockGetClickPipeResults - Counter uint64 + mock *ClientMock + params *ClientMockGetClickPipeParams + paramPtrs *ClientMockGetClickPipeParamPtrs + expectationOrigins ClientMockGetClickPipeExpectationOrigins + results *ClientMockGetClickPipeResults + returnOrigin string + Counter uint64 } // ClientMockGetClickPipeParams contains parameters of the Client.GetClickPipe @@ -5542,6 +6754,14 @@ type ClientMockGetClickPipeResults struct { err error } +// ClientMockGetClickPipeOrigins contains origins of expectations of the Client.GetClickPipe +type ClientMockGetClickPipeExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originClickPipeId string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -5567,6 +6787,7 @@ func (mmGetClickPipe *mClientMockGetClickPipe) Expect(ctx context.Context, servi } mmGetClickPipe.defaultExpectation.params = &ClientMockGetClickPipeParams{ctx, serviceId, clickPipeId} + mmGetClickPipe.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetClickPipe.expectations { if minimock.Equal(e.params, mmGetClickPipe.defaultExpectation.params) { mmGetClickPipe.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetClickPipe.defaultExpectation.params) @@ -5594,6 +6815,7 @@ func (mmGetClickPipe *mClientMockGetClickPipe) ExpectCtxParam1(ctx context.Conte mmGetClickPipe.defaultExpectation.paramPtrs = &ClientMockGetClickPipeParamPtrs{} } mmGetClickPipe.defaultExpectation.paramPtrs.ctx = &ctx + mmGetClickPipe.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetClickPipe } @@ -5616,6 +6838,7 @@ func (mmGetClickPipe *mClientMockGetClickPipe) ExpectServiceIdParam2(serviceId s mmGetClickPipe.defaultExpectation.paramPtrs = &ClientMockGetClickPipeParamPtrs{} } mmGetClickPipe.defaultExpectation.paramPtrs.serviceId = &serviceId + mmGetClickPipe.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmGetClickPipe } @@ -5638,6 +6861,7 @@ func (mmGetClickPipe *mClientMockGetClickPipe) ExpectClickPipeIdParam3(clickPipe mmGetClickPipe.defaultExpectation.paramPtrs = &ClientMockGetClickPipeParamPtrs{} } mmGetClickPipe.defaultExpectation.paramPtrs.clickPipeId = &clickPipeId + mmGetClickPipe.defaultExpectation.expectationOrigins.originClickPipeId = minimock.CallerInfo(1) return mmGetClickPipe } @@ -5663,6 +6887,7 @@ func (mmGetClickPipe *mClientMockGetClickPipe) Return(cp1 *ClickPipe, err error) mmGetClickPipe.defaultExpectation = &ClientMockGetClickPipeExpectation{mock: mmGetClickPipe.mock} } mmGetClickPipe.defaultExpectation.results = &ClientMockGetClickPipeResults{cp1, err} + mmGetClickPipe.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetClickPipe.mock } @@ -5677,6 +6902,7 @@ func (mmGetClickPipe *mClientMockGetClickPipe) Set(f func(ctx context.Context, s } mmGetClickPipe.mock.funcGetClickPipe = f + mmGetClickPipe.mock.funcGetClickPipeOrigin = minimock.CallerInfo(1) return mmGetClickPipe.mock } @@ -5688,8 +6914,9 @@ func (mmGetClickPipe *mClientMockGetClickPipe) When(ctx context.Context, service } expectation := &ClientMockGetClickPipeExpectation{ - mock: mmGetClickPipe.mock, - params: &ClientMockGetClickPipeParams{ctx, serviceId, clickPipeId}, + mock: mmGetClickPipe.mock, + params: &ClientMockGetClickPipeParams{ctx, serviceId, clickPipeId}, + expectationOrigins: ClientMockGetClickPipeExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetClickPipe.expectations = append(mmGetClickPipe.expectations, expectation) return expectation @@ -5707,6 +6934,7 @@ func (mmGetClickPipe *mClientMockGetClickPipe) Times(n uint64) *mClientMockGetCl mmGetClickPipe.mock.t.Fatalf("Times of ClientMock.GetClickPipe mock can not be zero") } mm_atomic.StoreUint64(&mmGetClickPipe.expectedInvocations, n) + mmGetClickPipe.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetClickPipe } @@ -5726,6 +6954,8 @@ func (mmGetClickPipe *ClientMock) GetClickPipe(ctx context.Context, serviceId st mm_atomic.AddUint64(&mmGetClickPipe.beforeGetClickPipeCounter, 1) defer mm_atomic.AddUint64(&mmGetClickPipe.afterGetClickPipeCounter, 1) + mmGetClickPipe.t.Helper() + if mmGetClickPipe.inspectFuncGetClickPipe != nil { mmGetClickPipe.inspectFuncGetClickPipe(ctx, serviceId, clickPipeId) } @@ -5754,19 +6984,23 @@ func (mmGetClickPipe *ClientMock) GetClickPipe(ctx context.Context, serviceId st if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetClickPipe.t.Errorf("ClientMock.GetClickPipe got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetClickPipe.t.Errorf("ClientMock.GetClickPipe got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetClickPipe.GetClickPipeMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmGetClickPipe.t.Errorf("ClientMock.GetClickPipe got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmGetClickPipe.t.Errorf("ClientMock.GetClickPipe got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetClickPipe.GetClickPipeMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.clickPipeId != nil && !minimock.Equal(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId) { - mmGetClickPipe.t.Errorf("ClientMock.GetClickPipe got unexpected parameter clickPipeId, want: %#v, got: %#v%s\n", *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) + mmGetClickPipe.t.Errorf("ClientMock.GetClickPipe got unexpected parameter clickPipeId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetClickPipe.GetClickPipeMock.defaultExpectation.expectationOrigins.originClickPipeId, *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetClickPipe.t.Errorf("ClientMock.GetClickPipe got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetClickPipe.t.Errorf("ClientMock.GetClickPipe got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetClickPipe.GetClickPipeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetClickPipe.GetClickPipeMock.defaultExpectation.results @@ -5826,7 +7060,7 @@ func (m *ClientMock) MinimockGetClickPipeDone() bool { func (m *ClientMock) MinimockGetClickPipeInspect() { for _, e := range m.GetClickPipeMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetClickPipe with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetClickPipe at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -5834,19 +7068,19 @@ func (m *ClientMock) MinimockGetClickPipeInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetClickPipeMock.defaultExpectation != nil && afterGetClickPipeCounter < 1 { if m.GetClickPipeMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetClickPipe") + m.t.Errorf("Expected call to ClientMock.GetClickPipe at\n%s", m.GetClickPipeMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetClickPipe with params: %#v", *m.GetClickPipeMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetClickPipe at\n%s with params: %#v", m.GetClickPipeMock.defaultExpectation.expectationOrigins.origin, *m.GetClickPipeMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetClickPipe != nil && afterGetClickPipeCounter < 1 { - m.t.Error("Expected call to ClientMock.GetClickPipe") + m.t.Errorf("Expected call to ClientMock.GetClickPipe at\n%s", m.funcGetClickPipeOrigin) } if !m.GetClickPipeMock.invocationsDone() && afterGetClickPipeCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetClickPipe but found %d calls", - mm_atomic.LoadUint64(&m.GetClickPipeMock.expectedInvocations), afterGetClickPipeCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetClickPipe at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetClickPipeMock.expectedInvocations), m.GetClickPipeMock.expectedInvocationsOrigin, afterGetClickPipeCounter) } } @@ -5859,16 +7093,19 @@ type mClientMockGetDatabase struct { callArgs []*ClientMockGetDatabaseParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetDatabaseExpectation specifies expectation struct of the Client.GetDatabase type ClientMockGetDatabaseExpectation struct { - mock *ClientMock - params *ClientMockGetDatabaseParams - paramPtrs *ClientMockGetDatabaseParamPtrs - results *ClientMockGetDatabaseResults - Counter uint64 + mock *ClientMock + params *ClientMockGetDatabaseParams + paramPtrs *ClientMockGetDatabaseParamPtrs + expectationOrigins ClientMockGetDatabaseExpectationOrigins + results *ClientMockGetDatabaseResults + returnOrigin string + Counter uint64 } // ClientMockGetDatabaseParams contains parameters of the Client.GetDatabase @@ -5891,6 +7128,14 @@ type ClientMockGetDatabaseResults struct { err error } +// ClientMockGetDatabaseOrigins contains origins of expectations of the Client.GetDatabase +type ClientMockGetDatabaseExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -5916,6 +7161,7 @@ func (mmGetDatabase *mClientMockGetDatabase) Expect(ctx context.Context, service } mmGetDatabase.defaultExpectation.params = &ClientMockGetDatabaseParams{ctx, serviceID, name} + mmGetDatabase.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetDatabase.expectations { if minimock.Equal(e.params, mmGetDatabase.defaultExpectation.params) { mmGetDatabase.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetDatabase.defaultExpectation.params) @@ -5943,6 +7189,7 @@ func (mmGetDatabase *mClientMockGetDatabase) ExpectCtxParam1(ctx context.Context mmGetDatabase.defaultExpectation.paramPtrs = &ClientMockGetDatabaseParamPtrs{} } mmGetDatabase.defaultExpectation.paramPtrs.ctx = &ctx + mmGetDatabase.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetDatabase } @@ -5965,6 +7212,7 @@ func (mmGetDatabase *mClientMockGetDatabase) ExpectServiceIDParam2(serviceID str mmGetDatabase.defaultExpectation.paramPtrs = &ClientMockGetDatabaseParamPtrs{} } mmGetDatabase.defaultExpectation.paramPtrs.serviceID = &serviceID + mmGetDatabase.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmGetDatabase } @@ -5987,6 +7235,7 @@ func (mmGetDatabase *mClientMockGetDatabase) ExpectNameParam3(name string) *mCli mmGetDatabase.defaultExpectation.paramPtrs = &ClientMockGetDatabaseParamPtrs{} } mmGetDatabase.defaultExpectation.paramPtrs.name = &name + mmGetDatabase.defaultExpectation.expectationOrigins.originName = minimock.CallerInfo(1) return mmGetDatabase } @@ -6012,6 +7261,7 @@ func (mmGetDatabase *mClientMockGetDatabase) Return(dp1 *Database, err error) *C mmGetDatabase.defaultExpectation = &ClientMockGetDatabaseExpectation{mock: mmGetDatabase.mock} } mmGetDatabase.defaultExpectation.results = &ClientMockGetDatabaseResults{dp1, err} + mmGetDatabase.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetDatabase.mock } @@ -6026,6 +7276,7 @@ func (mmGetDatabase *mClientMockGetDatabase) Set(f func(ctx context.Context, ser } mmGetDatabase.mock.funcGetDatabase = f + mmGetDatabase.mock.funcGetDatabaseOrigin = minimock.CallerInfo(1) return mmGetDatabase.mock } @@ -6037,8 +7288,9 @@ func (mmGetDatabase *mClientMockGetDatabase) When(ctx context.Context, serviceID } expectation := &ClientMockGetDatabaseExpectation{ - mock: mmGetDatabase.mock, - params: &ClientMockGetDatabaseParams{ctx, serviceID, name}, + mock: mmGetDatabase.mock, + params: &ClientMockGetDatabaseParams{ctx, serviceID, name}, + expectationOrigins: ClientMockGetDatabaseExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetDatabase.expectations = append(mmGetDatabase.expectations, expectation) return expectation @@ -6056,6 +7308,7 @@ func (mmGetDatabase *mClientMockGetDatabase) Times(n uint64) *mClientMockGetData mmGetDatabase.mock.t.Fatalf("Times of ClientMock.GetDatabase mock can not be zero") } mm_atomic.StoreUint64(&mmGetDatabase.expectedInvocations, n) + mmGetDatabase.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetDatabase } @@ -6075,6 +7328,8 @@ func (mmGetDatabase *ClientMock) GetDatabase(ctx context.Context, serviceID stri mm_atomic.AddUint64(&mmGetDatabase.beforeGetDatabaseCounter, 1) defer mm_atomic.AddUint64(&mmGetDatabase.afterGetDatabaseCounter, 1) + mmGetDatabase.t.Helper() + if mmGetDatabase.inspectFuncGetDatabase != nil { mmGetDatabase.inspectFuncGetDatabase(ctx, serviceID, name) } @@ -6103,19 +7358,23 @@ func (mmGetDatabase *ClientMock) GetDatabase(ctx context.Context, serviceID stri if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetDatabase.t.Errorf("ClientMock.GetDatabase got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetDatabase.t.Errorf("ClientMock.GetDatabase got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetDatabase.GetDatabaseMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmGetDatabase.t.Errorf("ClientMock.GetDatabase got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmGetDatabase.t.Errorf("ClientMock.GetDatabase got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetDatabase.GetDatabaseMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.name != nil && !minimock.Equal(*mm_want_ptrs.name, mm_got.name) { - mmGetDatabase.t.Errorf("ClientMock.GetDatabase got unexpected parameter name, want: %#v, got: %#v%s\n", *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) + mmGetDatabase.t.Errorf("ClientMock.GetDatabase got unexpected parameter name, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetDatabase.GetDatabaseMock.defaultExpectation.expectationOrigins.originName, *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetDatabase.t.Errorf("ClientMock.GetDatabase got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetDatabase.t.Errorf("ClientMock.GetDatabase got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetDatabase.GetDatabaseMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetDatabase.GetDatabaseMock.defaultExpectation.results @@ -6175,7 +7434,7 @@ func (m *ClientMock) MinimockGetDatabaseDone() bool { func (m *ClientMock) MinimockGetDatabaseInspect() { for _, e := range m.GetDatabaseMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetDatabase with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetDatabase at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -6183,19 +7442,19 @@ func (m *ClientMock) MinimockGetDatabaseInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetDatabaseMock.defaultExpectation != nil && afterGetDatabaseCounter < 1 { if m.GetDatabaseMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetDatabase") + m.t.Errorf("Expected call to ClientMock.GetDatabase at\n%s", m.GetDatabaseMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetDatabase with params: %#v", *m.GetDatabaseMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetDatabase at\n%s with params: %#v", m.GetDatabaseMock.defaultExpectation.expectationOrigins.origin, *m.GetDatabaseMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetDatabase != nil && afterGetDatabaseCounter < 1 { - m.t.Error("Expected call to ClientMock.GetDatabase") + m.t.Errorf("Expected call to ClientMock.GetDatabase at\n%s", m.funcGetDatabaseOrigin) } if !m.GetDatabaseMock.invocationsDone() && afterGetDatabaseCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetDatabase but found %d calls", - mm_atomic.LoadUint64(&m.GetDatabaseMock.expectedInvocations), afterGetDatabaseCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetDatabase at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetDatabaseMock.expectedInvocations), m.GetDatabaseMock.expectedInvocationsOrigin, afterGetDatabaseCounter) } } @@ -6208,16 +7467,19 @@ type mClientMockGetGrantPrivilege struct { callArgs []*ClientMockGetGrantPrivilegeParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetGrantPrivilegeExpectation specifies expectation struct of the Client.GetGrantPrivilege type ClientMockGetGrantPrivilegeExpectation struct { - mock *ClientMock - params *ClientMockGetGrantPrivilegeParams - paramPtrs *ClientMockGetGrantPrivilegeParamPtrs - results *ClientMockGetGrantPrivilegeResults - Counter uint64 + mock *ClientMock + params *ClientMockGetGrantPrivilegeParams + paramPtrs *ClientMockGetGrantPrivilegeParamPtrs + expectationOrigins ClientMockGetGrantPrivilegeExpectationOrigins + results *ClientMockGetGrantPrivilegeResults + returnOrigin string + Counter uint64 } // ClientMockGetGrantPrivilegeParams contains parameters of the Client.GetGrantPrivilege @@ -6250,6 +7512,19 @@ type ClientMockGetGrantPrivilegeResults struct { err error } +// ClientMockGetGrantPrivilegeOrigins contains origins of expectations of the Client.GetGrantPrivilege +type ClientMockGetGrantPrivilegeExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originAccessType string + originDatabase string + originTable string + originColumn string + originGranteeUserName string + originGranteeRoleName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -6275,6 +7550,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) Expect(ctx context.Cont } mmGetGrantPrivilege.defaultExpectation.params = &ClientMockGetGrantPrivilegeParams{ctx, serviceID, accessType, database, table, column, granteeUserName, granteeRoleName} + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetGrantPrivilege.expectations { if minimock.Equal(e.params, mmGetGrantPrivilege.defaultExpectation.params) { mmGetGrantPrivilege.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetGrantPrivilege.defaultExpectation.params) @@ -6302,6 +7578,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) ExpectCtxParam1(ctx con mmGetGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGetGrantPrivilegeParamPtrs{} } mmGetGrantPrivilege.defaultExpectation.paramPtrs.ctx = &ctx + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6324,6 +7601,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) ExpectServiceIDParam2(s mmGetGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGetGrantPrivilegeParamPtrs{} } mmGetGrantPrivilege.defaultExpectation.paramPtrs.serviceID = &serviceID + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6346,6 +7624,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) ExpectAccessTypeParam3( mmGetGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGetGrantPrivilegeParamPtrs{} } mmGetGrantPrivilege.defaultExpectation.paramPtrs.accessType = &accessType + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.originAccessType = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6368,6 +7647,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) ExpectDatabaseParam4(da mmGetGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGetGrantPrivilegeParamPtrs{} } mmGetGrantPrivilege.defaultExpectation.paramPtrs.database = &database + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.originDatabase = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6390,6 +7670,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) ExpectTableParam5(table mmGetGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGetGrantPrivilegeParamPtrs{} } mmGetGrantPrivilege.defaultExpectation.paramPtrs.table = &table + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.originTable = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6412,6 +7693,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) ExpectColumnParam6(colu mmGetGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGetGrantPrivilegeParamPtrs{} } mmGetGrantPrivilege.defaultExpectation.paramPtrs.column = &column + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.originColumn = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6434,6 +7716,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) ExpectGranteeUserNamePa mmGetGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGetGrantPrivilegeParamPtrs{} } mmGetGrantPrivilege.defaultExpectation.paramPtrs.granteeUserName = &granteeUserName + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.originGranteeUserName = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6456,6 +7739,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) ExpectGranteeRoleNamePa mmGetGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGetGrantPrivilegeParamPtrs{} } mmGetGrantPrivilege.defaultExpectation.paramPtrs.granteeRoleName = &granteeRoleName + mmGetGrantPrivilege.defaultExpectation.expectationOrigins.originGranteeRoleName = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6481,6 +7765,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) Return(gp1 *GrantPrivil mmGetGrantPrivilege.defaultExpectation = &ClientMockGetGrantPrivilegeExpectation{mock: mmGetGrantPrivilege.mock} } mmGetGrantPrivilege.defaultExpectation.results = &ClientMockGetGrantPrivilegeResults{gp1, err} + mmGetGrantPrivilege.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetGrantPrivilege.mock } @@ -6495,6 +7780,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) Set(f func(ctx context. } mmGetGrantPrivilege.mock.funcGetGrantPrivilege = f + mmGetGrantPrivilege.mock.funcGetGrantPrivilegeOrigin = minimock.CallerInfo(1) return mmGetGrantPrivilege.mock } @@ -6506,8 +7792,9 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) When(ctx context.Contex } expectation := &ClientMockGetGrantPrivilegeExpectation{ - mock: mmGetGrantPrivilege.mock, - params: &ClientMockGetGrantPrivilegeParams{ctx, serviceID, accessType, database, table, column, granteeUserName, granteeRoleName}, + mock: mmGetGrantPrivilege.mock, + params: &ClientMockGetGrantPrivilegeParams{ctx, serviceID, accessType, database, table, column, granteeUserName, granteeRoleName}, + expectationOrigins: ClientMockGetGrantPrivilegeExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetGrantPrivilege.expectations = append(mmGetGrantPrivilege.expectations, expectation) return expectation @@ -6525,6 +7812,7 @@ func (mmGetGrantPrivilege *mClientMockGetGrantPrivilege) Times(n uint64) *mClien mmGetGrantPrivilege.mock.t.Fatalf("Times of ClientMock.GetGrantPrivilege mock can not be zero") } mm_atomic.StoreUint64(&mmGetGrantPrivilege.expectedInvocations, n) + mmGetGrantPrivilege.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetGrantPrivilege } @@ -6544,6 +7832,8 @@ func (mmGetGrantPrivilege *ClientMock) GetGrantPrivilege(ctx context.Context, se mm_atomic.AddUint64(&mmGetGrantPrivilege.beforeGetGrantPrivilegeCounter, 1) defer mm_atomic.AddUint64(&mmGetGrantPrivilege.afterGetGrantPrivilegeCounter, 1) + mmGetGrantPrivilege.t.Helper() + if mmGetGrantPrivilege.inspectFuncGetGrantPrivilege != nil { mmGetGrantPrivilege.inspectFuncGetGrantPrivilege(ctx, serviceID, accessType, database, table, column, granteeUserName, granteeRoleName) } @@ -6572,39 +7862,48 @@ func (mmGetGrantPrivilege *ClientMock) GetGrantPrivilege(ctx context.Context, se if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.accessType != nil && !minimock.Equal(*mm_want_ptrs.accessType, mm_got.accessType) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter accessType, want: %#v, got: %#v%s\n", *mm_want_ptrs.accessType, mm_got.accessType, minimock.Diff(*mm_want_ptrs.accessType, mm_got.accessType)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter accessType, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.originAccessType, *mm_want_ptrs.accessType, mm_got.accessType, minimock.Diff(*mm_want_ptrs.accessType, mm_got.accessType)) } if mm_want_ptrs.database != nil && !minimock.Equal(*mm_want_ptrs.database, mm_got.database) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter database, want: %#v, got: %#v%s\n", *mm_want_ptrs.database, mm_got.database, minimock.Diff(*mm_want_ptrs.database, mm_got.database)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter database, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.originDatabase, *mm_want_ptrs.database, mm_got.database, minimock.Diff(*mm_want_ptrs.database, mm_got.database)) } if mm_want_ptrs.table != nil && !minimock.Equal(*mm_want_ptrs.table, mm_got.table) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter table, want: %#v, got: %#v%s\n", *mm_want_ptrs.table, mm_got.table, minimock.Diff(*mm_want_ptrs.table, mm_got.table)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter table, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.originTable, *mm_want_ptrs.table, mm_got.table, minimock.Diff(*mm_want_ptrs.table, mm_got.table)) } if mm_want_ptrs.column != nil && !minimock.Equal(*mm_want_ptrs.column, mm_got.column) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter column, want: %#v, got: %#v%s\n", *mm_want_ptrs.column, mm_got.column, minimock.Diff(*mm_want_ptrs.column, mm_got.column)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter column, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.originColumn, *mm_want_ptrs.column, mm_got.column, minimock.Diff(*mm_want_ptrs.column, mm_got.column)) } if mm_want_ptrs.granteeUserName != nil && !minimock.Equal(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter granteeUserName, want: %#v, got: %#v%s\n", *mm_want_ptrs.granteeUserName, mm_got.granteeUserName, minimock.Diff(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter granteeUserName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.originGranteeUserName, *mm_want_ptrs.granteeUserName, mm_got.granteeUserName, minimock.Diff(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName)) } if mm_want_ptrs.granteeRoleName != nil && !minimock.Equal(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter granteeRoleName, want: %#v, got: %#v%s\n", *mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName, minimock.Diff(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameter granteeRoleName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.originGranteeRoleName, *mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName, minimock.Diff(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetGrantPrivilege.t.Errorf("ClientMock.GetGrantPrivilege got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetGrantPrivilege.GetGrantPrivilegeMock.defaultExpectation.results @@ -6664,7 +7963,7 @@ func (m *ClientMock) MinimockGetGrantPrivilegeDone() bool { func (m *ClientMock) MinimockGetGrantPrivilegeInspect() { for _, e := range m.GetGrantPrivilegeMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetGrantPrivilege with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetGrantPrivilege at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -6672,19 +7971,19 @@ func (m *ClientMock) MinimockGetGrantPrivilegeInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetGrantPrivilegeMock.defaultExpectation != nil && afterGetGrantPrivilegeCounter < 1 { if m.GetGrantPrivilegeMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetGrantPrivilege") + m.t.Errorf("Expected call to ClientMock.GetGrantPrivilege at\n%s", m.GetGrantPrivilegeMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetGrantPrivilege with params: %#v", *m.GetGrantPrivilegeMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetGrantPrivilege at\n%s with params: %#v", m.GetGrantPrivilegeMock.defaultExpectation.expectationOrigins.origin, *m.GetGrantPrivilegeMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetGrantPrivilege != nil && afterGetGrantPrivilegeCounter < 1 { - m.t.Error("Expected call to ClientMock.GetGrantPrivilege") + m.t.Errorf("Expected call to ClientMock.GetGrantPrivilege at\n%s", m.funcGetGrantPrivilegeOrigin) } if !m.GetGrantPrivilegeMock.invocationsDone() && afterGetGrantPrivilegeCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetGrantPrivilege but found %d calls", - mm_atomic.LoadUint64(&m.GetGrantPrivilegeMock.expectedInvocations), afterGetGrantPrivilegeCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetGrantPrivilege at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetGrantPrivilegeMock.expectedInvocations), m.GetGrantPrivilegeMock.expectedInvocationsOrigin, afterGetGrantPrivilegeCounter) } } @@ -6697,16 +7996,19 @@ type mClientMockGetGrantRole struct { callArgs []*ClientMockGetGrantRoleParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetGrantRoleExpectation specifies expectation struct of the Client.GetGrantRole type ClientMockGetGrantRoleExpectation struct { - mock *ClientMock - params *ClientMockGetGrantRoleParams - paramPtrs *ClientMockGetGrantRoleParamPtrs - results *ClientMockGetGrantRoleResults - Counter uint64 + mock *ClientMock + params *ClientMockGetGrantRoleParams + paramPtrs *ClientMockGetGrantRoleParamPtrs + expectationOrigins ClientMockGetGrantRoleExpectationOrigins + results *ClientMockGetGrantRoleResults + returnOrigin string + Counter uint64 } // ClientMockGetGrantRoleParams contains parameters of the Client.GetGrantRole @@ -6733,6 +8035,16 @@ type ClientMockGetGrantRoleResults struct { err error } +// ClientMockGetGrantRoleOrigins contains origins of expectations of the Client.GetGrantRole +type ClientMockGetGrantRoleExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originGrantedRoleName string + originGranteeUserName string + originGranteeRoleName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -6758,6 +8070,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) Expect(ctx context.Context, servi } mmGetGrantRole.defaultExpectation.params = &ClientMockGetGrantRoleParams{ctx, serviceID, grantedRoleName, granteeUserName, granteeRoleName} + mmGetGrantRole.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetGrantRole.expectations { if minimock.Equal(e.params, mmGetGrantRole.defaultExpectation.params) { mmGetGrantRole.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetGrantRole.defaultExpectation.params) @@ -6785,6 +8098,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) ExpectCtxParam1(ctx context.Conte mmGetGrantRole.defaultExpectation.paramPtrs = &ClientMockGetGrantRoleParamPtrs{} } mmGetGrantRole.defaultExpectation.paramPtrs.ctx = &ctx + mmGetGrantRole.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetGrantRole } @@ -6807,6 +8121,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) ExpectServiceIDParam2(serviceID s mmGetGrantRole.defaultExpectation.paramPtrs = &ClientMockGetGrantRoleParamPtrs{} } mmGetGrantRole.defaultExpectation.paramPtrs.serviceID = &serviceID + mmGetGrantRole.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmGetGrantRole } @@ -6829,6 +8144,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) ExpectGrantedRoleNameParam3(grant mmGetGrantRole.defaultExpectation.paramPtrs = &ClientMockGetGrantRoleParamPtrs{} } mmGetGrantRole.defaultExpectation.paramPtrs.grantedRoleName = &grantedRoleName + mmGetGrantRole.defaultExpectation.expectationOrigins.originGrantedRoleName = minimock.CallerInfo(1) return mmGetGrantRole } @@ -6851,6 +8167,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) ExpectGranteeUserNameParam4(grant mmGetGrantRole.defaultExpectation.paramPtrs = &ClientMockGetGrantRoleParamPtrs{} } mmGetGrantRole.defaultExpectation.paramPtrs.granteeUserName = &granteeUserName + mmGetGrantRole.defaultExpectation.expectationOrigins.originGranteeUserName = minimock.CallerInfo(1) return mmGetGrantRole } @@ -6873,6 +8190,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) ExpectGranteeRoleNameParam5(grant mmGetGrantRole.defaultExpectation.paramPtrs = &ClientMockGetGrantRoleParamPtrs{} } mmGetGrantRole.defaultExpectation.paramPtrs.granteeRoleName = &granteeRoleName + mmGetGrantRole.defaultExpectation.expectationOrigins.originGranteeRoleName = minimock.CallerInfo(1) return mmGetGrantRole } @@ -6898,6 +8216,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) Return(gp1 *GrantRole, err error) mmGetGrantRole.defaultExpectation = &ClientMockGetGrantRoleExpectation{mock: mmGetGrantRole.mock} } mmGetGrantRole.defaultExpectation.results = &ClientMockGetGrantRoleResults{gp1, err} + mmGetGrantRole.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetGrantRole.mock } @@ -6912,6 +8231,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) Set(f func(ctx context.Context, s } mmGetGrantRole.mock.funcGetGrantRole = f + mmGetGrantRole.mock.funcGetGrantRoleOrigin = minimock.CallerInfo(1) return mmGetGrantRole.mock } @@ -6923,8 +8243,9 @@ func (mmGetGrantRole *mClientMockGetGrantRole) When(ctx context.Context, service } expectation := &ClientMockGetGrantRoleExpectation{ - mock: mmGetGrantRole.mock, - params: &ClientMockGetGrantRoleParams{ctx, serviceID, grantedRoleName, granteeUserName, granteeRoleName}, + mock: mmGetGrantRole.mock, + params: &ClientMockGetGrantRoleParams{ctx, serviceID, grantedRoleName, granteeUserName, granteeRoleName}, + expectationOrigins: ClientMockGetGrantRoleExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetGrantRole.expectations = append(mmGetGrantRole.expectations, expectation) return expectation @@ -6942,6 +8263,7 @@ func (mmGetGrantRole *mClientMockGetGrantRole) Times(n uint64) *mClientMockGetGr mmGetGrantRole.mock.t.Fatalf("Times of ClientMock.GetGrantRole mock can not be zero") } mm_atomic.StoreUint64(&mmGetGrantRole.expectedInvocations, n) + mmGetGrantRole.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetGrantRole } @@ -6961,6 +8283,8 @@ func (mmGetGrantRole *ClientMock) GetGrantRole(ctx context.Context, serviceID st mm_atomic.AddUint64(&mmGetGrantRole.beforeGetGrantRoleCounter, 1) defer mm_atomic.AddUint64(&mmGetGrantRole.afterGetGrantRoleCounter, 1) + mmGetGrantRole.t.Helper() + if mmGetGrantRole.inspectFuncGetGrantRole != nil { mmGetGrantRole.inspectFuncGetGrantRole(ctx, serviceID, grantedRoleName, granteeUserName, granteeRoleName) } @@ -6989,27 +8313,33 @@ func (mmGetGrantRole *ClientMock) GetGrantRole(ctx context.Context, serviceID st if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantRole.GetGrantRoleMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantRole.GetGrantRoleMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.grantedRoleName != nil && !minimock.Equal(*mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName) { - mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter grantedRoleName, want: %#v, got: %#v%s\n", *mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName, minimock.Diff(*mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName)) + mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter grantedRoleName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantRole.GetGrantRoleMock.defaultExpectation.expectationOrigins.originGrantedRoleName, *mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName, minimock.Diff(*mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName)) } if mm_want_ptrs.granteeUserName != nil && !minimock.Equal(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName) { - mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter granteeUserName, want: %#v, got: %#v%s\n", *mm_want_ptrs.granteeUserName, mm_got.granteeUserName, minimock.Diff(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName)) + mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter granteeUserName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantRole.GetGrantRoleMock.defaultExpectation.expectationOrigins.originGranteeUserName, *mm_want_ptrs.granteeUserName, mm_got.granteeUserName, minimock.Diff(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName)) } if mm_want_ptrs.granteeRoleName != nil && !minimock.Equal(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName) { - mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter granteeRoleName, want: %#v, got: %#v%s\n", *mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName, minimock.Diff(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName)) + mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameter granteeRoleName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantRole.GetGrantRoleMock.defaultExpectation.expectationOrigins.originGranteeRoleName, *mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName, minimock.Diff(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetGrantRole.t.Errorf("ClientMock.GetGrantRole got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetGrantRole.GetGrantRoleMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetGrantRole.GetGrantRoleMock.defaultExpectation.results @@ -7069,7 +8399,7 @@ func (m *ClientMock) MinimockGetGrantRoleDone() bool { func (m *ClientMock) MinimockGetGrantRoleInspect() { for _, e := range m.GetGrantRoleMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetGrantRole with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetGrantRole at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -7077,19 +8407,19 @@ func (m *ClientMock) MinimockGetGrantRoleInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetGrantRoleMock.defaultExpectation != nil && afterGetGrantRoleCounter < 1 { if m.GetGrantRoleMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetGrantRole") + m.t.Errorf("Expected call to ClientMock.GetGrantRole at\n%s", m.GetGrantRoleMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetGrantRole with params: %#v", *m.GetGrantRoleMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetGrantRole at\n%s with params: %#v", m.GetGrantRoleMock.defaultExpectation.expectationOrigins.origin, *m.GetGrantRoleMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetGrantRole != nil && afterGetGrantRoleCounter < 1 { - m.t.Error("Expected call to ClientMock.GetGrantRole") + m.t.Errorf("Expected call to ClientMock.GetGrantRole at\n%s", m.funcGetGrantRoleOrigin) } if !m.GetGrantRoleMock.invocationsDone() && afterGetGrantRoleCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetGrantRole but found %d calls", - mm_atomic.LoadUint64(&m.GetGrantRoleMock.expectedInvocations), afterGetGrantRoleCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetGrantRole at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetGrantRoleMock.expectedInvocations), m.GetGrantRoleMock.expectedInvocationsOrigin, afterGetGrantRoleCounter) } } @@ -7102,16 +8432,19 @@ type mClientMockGetOrgPrivateEndpointConfig struct { callArgs []*ClientMockGetOrgPrivateEndpointConfigParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetOrgPrivateEndpointConfigExpectation specifies expectation struct of the Client.GetOrgPrivateEndpointConfig type ClientMockGetOrgPrivateEndpointConfigExpectation struct { - mock *ClientMock - params *ClientMockGetOrgPrivateEndpointConfigParams - paramPtrs *ClientMockGetOrgPrivateEndpointConfigParamPtrs - results *ClientMockGetOrgPrivateEndpointConfigResults - Counter uint64 + mock *ClientMock + params *ClientMockGetOrgPrivateEndpointConfigParams + paramPtrs *ClientMockGetOrgPrivateEndpointConfigParamPtrs + expectationOrigins ClientMockGetOrgPrivateEndpointConfigExpectationOrigins + results *ClientMockGetOrgPrivateEndpointConfigResults + returnOrigin string + Counter uint64 } // ClientMockGetOrgPrivateEndpointConfigParams contains parameters of the Client.GetOrgPrivateEndpointConfig @@ -7134,6 +8467,14 @@ type ClientMockGetOrgPrivateEndpointConfigResults struct { err error } +// ClientMockGetOrgPrivateEndpointConfigOrigins contains origins of expectations of the Client.GetOrgPrivateEndpointConfig +type ClientMockGetOrgPrivateEndpointConfigExpectationOrigins struct { + origin string + originCtx string + originCloudProvider string + originRegion string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -7159,6 +8500,7 @@ func (mmGetOrgPrivateEndpointConfig *mClientMockGetOrgPrivateEndpointConfig) Exp } mmGetOrgPrivateEndpointConfig.defaultExpectation.params = &ClientMockGetOrgPrivateEndpointConfigParams{ctx, cloudProvider, region} + mmGetOrgPrivateEndpointConfig.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetOrgPrivateEndpointConfig.expectations { if minimock.Equal(e.params, mmGetOrgPrivateEndpointConfig.defaultExpectation.params) { mmGetOrgPrivateEndpointConfig.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetOrgPrivateEndpointConfig.defaultExpectation.params) @@ -7186,6 +8528,7 @@ func (mmGetOrgPrivateEndpointConfig *mClientMockGetOrgPrivateEndpointConfig) Exp mmGetOrgPrivateEndpointConfig.defaultExpectation.paramPtrs = &ClientMockGetOrgPrivateEndpointConfigParamPtrs{} } mmGetOrgPrivateEndpointConfig.defaultExpectation.paramPtrs.ctx = &ctx + mmGetOrgPrivateEndpointConfig.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetOrgPrivateEndpointConfig } @@ -7208,6 +8551,7 @@ func (mmGetOrgPrivateEndpointConfig *mClientMockGetOrgPrivateEndpointConfig) Exp mmGetOrgPrivateEndpointConfig.defaultExpectation.paramPtrs = &ClientMockGetOrgPrivateEndpointConfigParamPtrs{} } mmGetOrgPrivateEndpointConfig.defaultExpectation.paramPtrs.cloudProvider = &cloudProvider + mmGetOrgPrivateEndpointConfig.defaultExpectation.expectationOrigins.originCloudProvider = minimock.CallerInfo(1) return mmGetOrgPrivateEndpointConfig } @@ -7230,6 +8574,7 @@ func (mmGetOrgPrivateEndpointConfig *mClientMockGetOrgPrivateEndpointConfig) Exp mmGetOrgPrivateEndpointConfig.defaultExpectation.paramPtrs = &ClientMockGetOrgPrivateEndpointConfigParamPtrs{} } mmGetOrgPrivateEndpointConfig.defaultExpectation.paramPtrs.region = ®ion + mmGetOrgPrivateEndpointConfig.defaultExpectation.expectationOrigins.originRegion = minimock.CallerInfo(1) return mmGetOrgPrivateEndpointConfig } @@ -7255,6 +8600,7 @@ func (mmGetOrgPrivateEndpointConfig *mClientMockGetOrgPrivateEndpointConfig) Ret mmGetOrgPrivateEndpointConfig.defaultExpectation = &ClientMockGetOrgPrivateEndpointConfigExpectation{mock: mmGetOrgPrivateEndpointConfig.mock} } mmGetOrgPrivateEndpointConfig.defaultExpectation.results = &ClientMockGetOrgPrivateEndpointConfigResults{op1, err} + mmGetOrgPrivateEndpointConfig.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetOrgPrivateEndpointConfig.mock } @@ -7269,6 +8615,7 @@ func (mmGetOrgPrivateEndpointConfig *mClientMockGetOrgPrivateEndpointConfig) Set } mmGetOrgPrivateEndpointConfig.mock.funcGetOrgPrivateEndpointConfig = f + mmGetOrgPrivateEndpointConfig.mock.funcGetOrgPrivateEndpointConfigOrigin = minimock.CallerInfo(1) return mmGetOrgPrivateEndpointConfig.mock } @@ -7280,8 +8627,9 @@ func (mmGetOrgPrivateEndpointConfig *mClientMockGetOrgPrivateEndpointConfig) Whe } expectation := &ClientMockGetOrgPrivateEndpointConfigExpectation{ - mock: mmGetOrgPrivateEndpointConfig.mock, - params: &ClientMockGetOrgPrivateEndpointConfigParams{ctx, cloudProvider, region}, + mock: mmGetOrgPrivateEndpointConfig.mock, + params: &ClientMockGetOrgPrivateEndpointConfigParams{ctx, cloudProvider, region}, + expectationOrigins: ClientMockGetOrgPrivateEndpointConfigExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetOrgPrivateEndpointConfig.expectations = append(mmGetOrgPrivateEndpointConfig.expectations, expectation) return expectation @@ -7299,6 +8647,7 @@ func (mmGetOrgPrivateEndpointConfig *mClientMockGetOrgPrivateEndpointConfig) Tim mmGetOrgPrivateEndpointConfig.mock.t.Fatalf("Times of ClientMock.GetOrgPrivateEndpointConfig mock can not be zero") } mm_atomic.StoreUint64(&mmGetOrgPrivateEndpointConfig.expectedInvocations, n) + mmGetOrgPrivateEndpointConfig.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetOrgPrivateEndpointConfig } @@ -7318,6 +8667,8 @@ func (mmGetOrgPrivateEndpointConfig *ClientMock) GetOrgPrivateEndpointConfig(ctx mm_atomic.AddUint64(&mmGetOrgPrivateEndpointConfig.beforeGetOrgPrivateEndpointConfigCounter, 1) defer mm_atomic.AddUint64(&mmGetOrgPrivateEndpointConfig.afterGetOrgPrivateEndpointConfigCounter, 1) + mmGetOrgPrivateEndpointConfig.t.Helper() + if mmGetOrgPrivateEndpointConfig.inspectFuncGetOrgPrivateEndpointConfig != nil { mmGetOrgPrivateEndpointConfig.inspectFuncGetOrgPrivateEndpointConfig(ctx, cloudProvider, region) } @@ -7346,19 +8697,23 @@ func (mmGetOrgPrivateEndpointConfig *ClientMock) GetOrgPrivateEndpointConfig(ctx if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetOrgPrivateEndpointConfig.t.Errorf("ClientMock.GetOrgPrivateEndpointConfig got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetOrgPrivateEndpointConfig.t.Errorf("ClientMock.GetOrgPrivateEndpointConfig got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetOrgPrivateEndpointConfig.GetOrgPrivateEndpointConfigMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.cloudProvider != nil && !minimock.Equal(*mm_want_ptrs.cloudProvider, mm_got.cloudProvider) { - mmGetOrgPrivateEndpointConfig.t.Errorf("ClientMock.GetOrgPrivateEndpointConfig got unexpected parameter cloudProvider, want: %#v, got: %#v%s\n", *mm_want_ptrs.cloudProvider, mm_got.cloudProvider, minimock.Diff(*mm_want_ptrs.cloudProvider, mm_got.cloudProvider)) + mmGetOrgPrivateEndpointConfig.t.Errorf("ClientMock.GetOrgPrivateEndpointConfig got unexpected parameter cloudProvider, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetOrgPrivateEndpointConfig.GetOrgPrivateEndpointConfigMock.defaultExpectation.expectationOrigins.originCloudProvider, *mm_want_ptrs.cloudProvider, mm_got.cloudProvider, minimock.Diff(*mm_want_ptrs.cloudProvider, mm_got.cloudProvider)) } if mm_want_ptrs.region != nil && !minimock.Equal(*mm_want_ptrs.region, mm_got.region) { - mmGetOrgPrivateEndpointConfig.t.Errorf("ClientMock.GetOrgPrivateEndpointConfig got unexpected parameter region, want: %#v, got: %#v%s\n", *mm_want_ptrs.region, mm_got.region, minimock.Diff(*mm_want_ptrs.region, mm_got.region)) + mmGetOrgPrivateEndpointConfig.t.Errorf("ClientMock.GetOrgPrivateEndpointConfig got unexpected parameter region, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetOrgPrivateEndpointConfig.GetOrgPrivateEndpointConfigMock.defaultExpectation.expectationOrigins.originRegion, *mm_want_ptrs.region, mm_got.region, minimock.Diff(*mm_want_ptrs.region, mm_got.region)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetOrgPrivateEndpointConfig.t.Errorf("ClientMock.GetOrgPrivateEndpointConfig got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetOrgPrivateEndpointConfig.t.Errorf("ClientMock.GetOrgPrivateEndpointConfig got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetOrgPrivateEndpointConfig.GetOrgPrivateEndpointConfigMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetOrgPrivateEndpointConfig.GetOrgPrivateEndpointConfigMock.defaultExpectation.results @@ -7418,7 +8773,7 @@ func (m *ClientMock) MinimockGetOrgPrivateEndpointConfigDone() bool { func (m *ClientMock) MinimockGetOrgPrivateEndpointConfigInspect() { for _, e := range m.GetOrgPrivateEndpointConfigMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetOrgPrivateEndpointConfig with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetOrgPrivateEndpointConfig at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -7426,19 +8781,19 @@ func (m *ClientMock) MinimockGetOrgPrivateEndpointConfigInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetOrgPrivateEndpointConfigMock.defaultExpectation != nil && afterGetOrgPrivateEndpointConfigCounter < 1 { if m.GetOrgPrivateEndpointConfigMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetOrgPrivateEndpointConfig") + m.t.Errorf("Expected call to ClientMock.GetOrgPrivateEndpointConfig at\n%s", m.GetOrgPrivateEndpointConfigMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetOrgPrivateEndpointConfig with params: %#v", *m.GetOrgPrivateEndpointConfigMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetOrgPrivateEndpointConfig at\n%s with params: %#v", m.GetOrgPrivateEndpointConfigMock.defaultExpectation.expectationOrigins.origin, *m.GetOrgPrivateEndpointConfigMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetOrgPrivateEndpointConfig != nil && afterGetOrgPrivateEndpointConfigCounter < 1 { - m.t.Error("Expected call to ClientMock.GetOrgPrivateEndpointConfig") + m.t.Errorf("Expected call to ClientMock.GetOrgPrivateEndpointConfig at\n%s", m.funcGetOrgPrivateEndpointConfigOrigin) } if !m.GetOrgPrivateEndpointConfigMock.invocationsDone() && afterGetOrgPrivateEndpointConfigCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetOrgPrivateEndpointConfig but found %d calls", - mm_atomic.LoadUint64(&m.GetOrgPrivateEndpointConfigMock.expectedInvocations), afterGetOrgPrivateEndpointConfigCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetOrgPrivateEndpointConfig at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetOrgPrivateEndpointConfigMock.expectedInvocations), m.GetOrgPrivateEndpointConfigMock.expectedInvocationsOrigin, afterGetOrgPrivateEndpointConfigCounter) } } @@ -7451,16 +8806,19 @@ type mClientMockGetOrganizationPrivateEndpoints struct { callArgs []*ClientMockGetOrganizationPrivateEndpointsParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetOrganizationPrivateEndpointsExpectation specifies expectation struct of the Client.GetOrganizationPrivateEndpoints type ClientMockGetOrganizationPrivateEndpointsExpectation struct { - mock *ClientMock - params *ClientMockGetOrganizationPrivateEndpointsParams - paramPtrs *ClientMockGetOrganizationPrivateEndpointsParamPtrs - results *ClientMockGetOrganizationPrivateEndpointsResults - Counter uint64 + mock *ClientMock + params *ClientMockGetOrganizationPrivateEndpointsParams + paramPtrs *ClientMockGetOrganizationPrivateEndpointsParamPtrs + expectationOrigins ClientMockGetOrganizationPrivateEndpointsExpectationOrigins + results *ClientMockGetOrganizationPrivateEndpointsResults + returnOrigin string + Counter uint64 } // ClientMockGetOrganizationPrivateEndpointsParams contains parameters of the Client.GetOrganizationPrivateEndpoints @@ -7479,6 +8837,12 @@ type ClientMockGetOrganizationPrivateEndpointsResults struct { err error } +// ClientMockGetOrganizationPrivateEndpointsOrigins contains origins of expectations of the Client.GetOrganizationPrivateEndpoints +type ClientMockGetOrganizationPrivateEndpointsExpectationOrigins struct { + origin string + originCtx string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -7504,6 +8868,7 @@ func (mmGetOrganizationPrivateEndpoints *mClientMockGetOrganizationPrivateEndpoi } mmGetOrganizationPrivateEndpoints.defaultExpectation.params = &ClientMockGetOrganizationPrivateEndpointsParams{ctx} + mmGetOrganizationPrivateEndpoints.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetOrganizationPrivateEndpoints.expectations { if minimock.Equal(e.params, mmGetOrganizationPrivateEndpoints.defaultExpectation.params) { mmGetOrganizationPrivateEndpoints.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetOrganizationPrivateEndpoints.defaultExpectation.params) @@ -7531,6 +8896,7 @@ func (mmGetOrganizationPrivateEndpoints *mClientMockGetOrganizationPrivateEndpoi mmGetOrganizationPrivateEndpoints.defaultExpectation.paramPtrs = &ClientMockGetOrganizationPrivateEndpointsParamPtrs{} } mmGetOrganizationPrivateEndpoints.defaultExpectation.paramPtrs.ctx = &ctx + mmGetOrganizationPrivateEndpoints.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetOrganizationPrivateEndpoints } @@ -7556,6 +8922,7 @@ func (mmGetOrganizationPrivateEndpoints *mClientMockGetOrganizationPrivateEndpoi mmGetOrganizationPrivateEndpoints.defaultExpectation = &ClientMockGetOrganizationPrivateEndpointsExpectation{mock: mmGetOrganizationPrivateEndpoints.mock} } mmGetOrganizationPrivateEndpoints.defaultExpectation.results = &ClientMockGetOrganizationPrivateEndpointsResults{pap1, err} + mmGetOrganizationPrivateEndpoints.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetOrganizationPrivateEndpoints.mock } @@ -7570,6 +8937,7 @@ func (mmGetOrganizationPrivateEndpoints *mClientMockGetOrganizationPrivateEndpoi } mmGetOrganizationPrivateEndpoints.mock.funcGetOrganizationPrivateEndpoints = f + mmGetOrganizationPrivateEndpoints.mock.funcGetOrganizationPrivateEndpointsOrigin = minimock.CallerInfo(1) return mmGetOrganizationPrivateEndpoints.mock } @@ -7581,8 +8949,9 @@ func (mmGetOrganizationPrivateEndpoints *mClientMockGetOrganizationPrivateEndpoi } expectation := &ClientMockGetOrganizationPrivateEndpointsExpectation{ - mock: mmGetOrganizationPrivateEndpoints.mock, - params: &ClientMockGetOrganizationPrivateEndpointsParams{ctx}, + mock: mmGetOrganizationPrivateEndpoints.mock, + params: &ClientMockGetOrganizationPrivateEndpointsParams{ctx}, + expectationOrigins: ClientMockGetOrganizationPrivateEndpointsExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetOrganizationPrivateEndpoints.expectations = append(mmGetOrganizationPrivateEndpoints.expectations, expectation) return expectation @@ -7600,6 +8969,7 @@ func (mmGetOrganizationPrivateEndpoints *mClientMockGetOrganizationPrivateEndpoi mmGetOrganizationPrivateEndpoints.mock.t.Fatalf("Times of ClientMock.GetOrganizationPrivateEndpoints mock can not be zero") } mm_atomic.StoreUint64(&mmGetOrganizationPrivateEndpoints.expectedInvocations, n) + mmGetOrganizationPrivateEndpoints.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetOrganizationPrivateEndpoints } @@ -7619,6 +8989,8 @@ func (mmGetOrganizationPrivateEndpoints *ClientMock) GetOrganizationPrivateEndpo mm_atomic.AddUint64(&mmGetOrganizationPrivateEndpoints.beforeGetOrganizationPrivateEndpointsCounter, 1) defer mm_atomic.AddUint64(&mmGetOrganizationPrivateEndpoints.afterGetOrganizationPrivateEndpointsCounter, 1) + mmGetOrganizationPrivateEndpoints.t.Helper() + if mmGetOrganizationPrivateEndpoints.inspectFuncGetOrganizationPrivateEndpoints != nil { mmGetOrganizationPrivateEndpoints.inspectFuncGetOrganizationPrivateEndpoints(ctx) } @@ -7647,11 +9019,13 @@ func (mmGetOrganizationPrivateEndpoints *ClientMock) GetOrganizationPrivateEndpo if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetOrganizationPrivateEndpoints.t.Errorf("ClientMock.GetOrganizationPrivateEndpoints got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetOrganizationPrivateEndpoints.t.Errorf("ClientMock.GetOrganizationPrivateEndpoints got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetOrganizationPrivateEndpoints.GetOrganizationPrivateEndpointsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetOrganizationPrivateEndpoints.t.Errorf("ClientMock.GetOrganizationPrivateEndpoints got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetOrganizationPrivateEndpoints.t.Errorf("ClientMock.GetOrganizationPrivateEndpoints got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetOrganizationPrivateEndpoints.GetOrganizationPrivateEndpointsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetOrganizationPrivateEndpoints.GetOrganizationPrivateEndpointsMock.defaultExpectation.results @@ -7711,7 +9085,7 @@ func (m *ClientMock) MinimockGetOrganizationPrivateEndpointsDone() bool { func (m *ClientMock) MinimockGetOrganizationPrivateEndpointsInspect() { for _, e := range m.GetOrganizationPrivateEndpointsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetOrganizationPrivateEndpoints with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetOrganizationPrivateEndpoints at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -7719,19 +9093,19 @@ func (m *ClientMock) MinimockGetOrganizationPrivateEndpointsInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetOrganizationPrivateEndpointsMock.defaultExpectation != nil && afterGetOrganizationPrivateEndpointsCounter < 1 { if m.GetOrganizationPrivateEndpointsMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetOrganizationPrivateEndpoints") + m.t.Errorf("Expected call to ClientMock.GetOrganizationPrivateEndpoints at\n%s", m.GetOrganizationPrivateEndpointsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetOrganizationPrivateEndpoints with params: %#v", *m.GetOrganizationPrivateEndpointsMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetOrganizationPrivateEndpoints at\n%s with params: %#v", m.GetOrganizationPrivateEndpointsMock.defaultExpectation.expectationOrigins.origin, *m.GetOrganizationPrivateEndpointsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetOrganizationPrivateEndpoints != nil && afterGetOrganizationPrivateEndpointsCounter < 1 { - m.t.Error("Expected call to ClientMock.GetOrganizationPrivateEndpoints") + m.t.Errorf("Expected call to ClientMock.GetOrganizationPrivateEndpoints at\n%s", m.funcGetOrganizationPrivateEndpointsOrigin) } if !m.GetOrganizationPrivateEndpointsMock.invocationsDone() && afterGetOrganizationPrivateEndpointsCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetOrganizationPrivateEndpoints but found %d calls", - mm_atomic.LoadUint64(&m.GetOrganizationPrivateEndpointsMock.expectedInvocations), afterGetOrganizationPrivateEndpointsCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetOrganizationPrivateEndpoints at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetOrganizationPrivateEndpointsMock.expectedInvocations), m.GetOrganizationPrivateEndpointsMock.expectedInvocationsOrigin, afterGetOrganizationPrivateEndpointsCounter) } } @@ -7744,16 +9118,19 @@ type mClientMockGetQueryEndpoint struct { callArgs []*ClientMockGetQueryEndpointParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetQueryEndpointExpectation specifies expectation struct of the Client.GetQueryEndpoint type ClientMockGetQueryEndpointExpectation struct { - mock *ClientMock - params *ClientMockGetQueryEndpointParams - paramPtrs *ClientMockGetQueryEndpointParamPtrs - results *ClientMockGetQueryEndpointResults - Counter uint64 + mock *ClientMock + params *ClientMockGetQueryEndpointParams + paramPtrs *ClientMockGetQueryEndpointParamPtrs + expectationOrigins ClientMockGetQueryEndpointExpectationOrigins + results *ClientMockGetQueryEndpointResults + returnOrigin string + Counter uint64 } // ClientMockGetQueryEndpointParams contains parameters of the Client.GetQueryEndpoint @@ -7774,6 +9151,13 @@ type ClientMockGetQueryEndpointResults struct { err error } +// ClientMockGetQueryEndpointOrigins contains origins of expectations of the Client.GetQueryEndpoint +type ClientMockGetQueryEndpointExpectationOrigins struct { + origin string + originCtx string + originServiceID string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -7799,6 +9183,7 @@ func (mmGetQueryEndpoint *mClientMockGetQueryEndpoint) Expect(ctx context.Contex } mmGetQueryEndpoint.defaultExpectation.params = &ClientMockGetQueryEndpointParams{ctx, serviceID} + mmGetQueryEndpoint.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetQueryEndpoint.expectations { if minimock.Equal(e.params, mmGetQueryEndpoint.defaultExpectation.params) { mmGetQueryEndpoint.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetQueryEndpoint.defaultExpectation.params) @@ -7826,6 +9211,7 @@ func (mmGetQueryEndpoint *mClientMockGetQueryEndpoint) ExpectCtxParam1(ctx conte mmGetQueryEndpoint.defaultExpectation.paramPtrs = &ClientMockGetQueryEndpointParamPtrs{} } mmGetQueryEndpoint.defaultExpectation.paramPtrs.ctx = &ctx + mmGetQueryEndpoint.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetQueryEndpoint } @@ -7848,6 +9234,7 @@ func (mmGetQueryEndpoint *mClientMockGetQueryEndpoint) ExpectServiceIDParam2(ser mmGetQueryEndpoint.defaultExpectation.paramPtrs = &ClientMockGetQueryEndpointParamPtrs{} } mmGetQueryEndpoint.defaultExpectation.paramPtrs.serviceID = &serviceID + mmGetQueryEndpoint.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmGetQueryEndpoint } @@ -7873,6 +9260,7 @@ func (mmGetQueryEndpoint *mClientMockGetQueryEndpoint) Return(sp1 *ServiceQueryE mmGetQueryEndpoint.defaultExpectation = &ClientMockGetQueryEndpointExpectation{mock: mmGetQueryEndpoint.mock} } mmGetQueryEndpoint.defaultExpectation.results = &ClientMockGetQueryEndpointResults{sp1, err} + mmGetQueryEndpoint.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetQueryEndpoint.mock } @@ -7887,6 +9275,7 @@ func (mmGetQueryEndpoint *mClientMockGetQueryEndpoint) Set(f func(ctx context.Co } mmGetQueryEndpoint.mock.funcGetQueryEndpoint = f + mmGetQueryEndpoint.mock.funcGetQueryEndpointOrigin = minimock.CallerInfo(1) return mmGetQueryEndpoint.mock } @@ -7898,8 +9287,9 @@ func (mmGetQueryEndpoint *mClientMockGetQueryEndpoint) When(ctx context.Context, } expectation := &ClientMockGetQueryEndpointExpectation{ - mock: mmGetQueryEndpoint.mock, - params: &ClientMockGetQueryEndpointParams{ctx, serviceID}, + mock: mmGetQueryEndpoint.mock, + params: &ClientMockGetQueryEndpointParams{ctx, serviceID}, + expectationOrigins: ClientMockGetQueryEndpointExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetQueryEndpoint.expectations = append(mmGetQueryEndpoint.expectations, expectation) return expectation @@ -7917,6 +9307,7 @@ func (mmGetQueryEndpoint *mClientMockGetQueryEndpoint) Times(n uint64) *mClientM mmGetQueryEndpoint.mock.t.Fatalf("Times of ClientMock.GetQueryEndpoint mock can not be zero") } mm_atomic.StoreUint64(&mmGetQueryEndpoint.expectedInvocations, n) + mmGetQueryEndpoint.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetQueryEndpoint } @@ -7936,6 +9327,8 @@ func (mmGetQueryEndpoint *ClientMock) GetQueryEndpoint(ctx context.Context, serv mm_atomic.AddUint64(&mmGetQueryEndpoint.beforeGetQueryEndpointCounter, 1) defer mm_atomic.AddUint64(&mmGetQueryEndpoint.afterGetQueryEndpointCounter, 1) + mmGetQueryEndpoint.t.Helper() + if mmGetQueryEndpoint.inspectFuncGetQueryEndpoint != nil { mmGetQueryEndpoint.inspectFuncGetQueryEndpoint(ctx, serviceID) } @@ -7964,15 +9357,18 @@ func (mmGetQueryEndpoint *ClientMock) GetQueryEndpoint(ctx context.Context, serv if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetQueryEndpoint.t.Errorf("ClientMock.GetQueryEndpoint got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetQueryEndpoint.t.Errorf("ClientMock.GetQueryEndpoint got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetQueryEndpoint.GetQueryEndpointMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmGetQueryEndpoint.t.Errorf("ClientMock.GetQueryEndpoint got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmGetQueryEndpoint.t.Errorf("ClientMock.GetQueryEndpoint got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetQueryEndpoint.GetQueryEndpointMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetQueryEndpoint.t.Errorf("ClientMock.GetQueryEndpoint got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetQueryEndpoint.t.Errorf("ClientMock.GetQueryEndpoint got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetQueryEndpoint.GetQueryEndpointMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetQueryEndpoint.GetQueryEndpointMock.defaultExpectation.results @@ -8032,7 +9428,7 @@ func (m *ClientMock) MinimockGetQueryEndpointDone() bool { func (m *ClientMock) MinimockGetQueryEndpointInspect() { for _, e := range m.GetQueryEndpointMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetQueryEndpoint with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetQueryEndpoint at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -8040,53 +9436,772 @@ func (m *ClientMock) MinimockGetQueryEndpointInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetQueryEndpointMock.defaultExpectation != nil && afterGetQueryEndpointCounter < 1 { if m.GetQueryEndpointMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetQueryEndpoint") + m.t.Errorf("Expected call to ClientMock.GetQueryEndpoint at\n%s", m.GetQueryEndpointMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetQueryEndpoint with params: %#v", *m.GetQueryEndpointMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetQueryEndpoint at\n%s with params: %#v", m.GetQueryEndpointMock.defaultExpectation.expectationOrigins.origin, *m.GetQueryEndpointMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetQueryEndpoint != nil && afterGetQueryEndpointCounter < 1 { - m.t.Error("Expected call to ClientMock.GetQueryEndpoint") + m.t.Errorf("Expected call to ClientMock.GetQueryEndpoint at\n%s", m.funcGetQueryEndpointOrigin) } if !m.GetQueryEndpointMock.invocationsDone() && afterGetQueryEndpointCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetQueryEndpoint but found %d calls", - mm_atomic.LoadUint64(&m.GetQueryEndpointMock.expectedInvocations), afterGetQueryEndpointCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetQueryEndpoint at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetQueryEndpointMock.expectedInvocations), m.GetQueryEndpointMock.expectedInvocationsOrigin, afterGetQueryEndpointCounter) } } -type mClientMockGetRole struct { +type mClientMockGetReversePrivateEndpoint struct { optional bool mock *ClientMock - defaultExpectation *ClientMockGetRoleExpectation - expectations []*ClientMockGetRoleExpectation + defaultExpectation *ClientMockGetReversePrivateEndpointExpectation + expectations []*ClientMockGetReversePrivateEndpointExpectation - callArgs []*ClientMockGetRoleParams + callArgs []*ClientMockGetReversePrivateEndpointParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } -// ClientMockGetRoleExpectation specifies expectation struct of the Client.GetRole -type ClientMockGetRoleExpectation struct { - mock *ClientMock - params *ClientMockGetRoleParams - paramPtrs *ClientMockGetRoleParamPtrs - results *ClientMockGetRoleResults - Counter uint64 +// ClientMockGetReversePrivateEndpointExpectation specifies expectation struct of the Client.GetReversePrivateEndpoint +type ClientMockGetReversePrivateEndpointExpectation struct { + mock *ClientMock + params *ClientMockGetReversePrivateEndpointParams + paramPtrs *ClientMockGetReversePrivateEndpointParamPtrs + expectationOrigins ClientMockGetReversePrivateEndpointExpectationOrigins + results *ClientMockGetReversePrivateEndpointResults + returnOrigin string + Counter uint64 } -// ClientMockGetRoleParams contains parameters of the Client.GetRole -type ClientMockGetRoleParams struct { - ctx context.Context - serviceID string - name string +// ClientMockGetReversePrivateEndpointParams contains parameters of the Client.GetReversePrivateEndpoint +type ClientMockGetReversePrivateEndpointParams struct { + ctx context.Context + serviceId string + reversePrivateEndpointId string } -// ClientMockGetRoleParamPtrs contains pointers to parameters of the Client.GetRole -type ClientMockGetRoleParamPtrs struct { - ctx *context.Context +// ClientMockGetReversePrivateEndpointParamPtrs contains pointers to parameters of the Client.GetReversePrivateEndpoint +type ClientMockGetReversePrivateEndpointParamPtrs struct { + ctx *context.Context + serviceId *string + reversePrivateEndpointId *string +} + +// ClientMockGetReversePrivateEndpointResults contains results of the Client.GetReversePrivateEndpoint +type ClientMockGetReversePrivateEndpointResults struct { + rp1 *ReversePrivateEndpoint + err error +} + +// ClientMockGetReversePrivateEndpointOrigins contains origins of expectations of the Client.GetReversePrivateEndpoint +type ClientMockGetReversePrivateEndpointExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originReversePrivateEndpointId string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) Optional() *mClientMockGetReversePrivateEndpoint { + mmGetReversePrivateEndpoint.optional = true + return mmGetReversePrivateEndpoint +} + +// Expect sets up expected params for Client.GetReversePrivateEndpoint +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) Expect(ctx context.Context, serviceId string, reversePrivateEndpointId string) *mClientMockGetReversePrivateEndpoint { + if mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpoint != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Set") + } + + if mmGetReversePrivateEndpoint.defaultExpectation == nil { + mmGetReversePrivateEndpoint.defaultExpectation = &ClientMockGetReversePrivateEndpointExpectation{} + } + + if mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by ExpectParams functions") + } + + mmGetReversePrivateEndpoint.defaultExpectation.params = &ClientMockGetReversePrivateEndpointParams{ctx, serviceId, reversePrivateEndpointId} + mmGetReversePrivateEndpoint.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetReversePrivateEndpoint.expectations { + if minimock.Equal(e.params, mmGetReversePrivateEndpoint.defaultExpectation.params) { + mmGetReversePrivateEndpoint.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetReversePrivateEndpoint.defaultExpectation.params) + } + } + + return mmGetReversePrivateEndpoint +} + +// ExpectCtxParam1 sets up expected param ctx for Client.GetReversePrivateEndpoint +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) ExpectCtxParam1(ctx context.Context) *mClientMockGetReversePrivateEndpoint { + if mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpoint != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Set") + } + + if mmGetReversePrivateEndpoint.defaultExpectation == nil { + mmGetReversePrivateEndpoint.defaultExpectation = &ClientMockGetReversePrivateEndpointExpectation{} + } + + if mmGetReversePrivateEndpoint.defaultExpectation.params != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Expect") + } + + if mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockGetReversePrivateEndpointParamPtrs{} + } + mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs.ctx = &ctx + mmGetReversePrivateEndpoint.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmGetReversePrivateEndpoint +} + +// ExpectServiceIdParam2 sets up expected param serviceId for Client.GetReversePrivateEndpoint +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) ExpectServiceIdParam2(serviceId string) *mClientMockGetReversePrivateEndpoint { + if mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpoint != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Set") + } + + if mmGetReversePrivateEndpoint.defaultExpectation == nil { + mmGetReversePrivateEndpoint.defaultExpectation = &ClientMockGetReversePrivateEndpointExpectation{} + } + + if mmGetReversePrivateEndpoint.defaultExpectation.params != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Expect") + } + + if mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockGetReversePrivateEndpointParamPtrs{} + } + mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs.serviceId = &serviceId + mmGetReversePrivateEndpoint.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) + + return mmGetReversePrivateEndpoint +} + +// ExpectReversePrivateEndpointIdParam3 sets up expected param reversePrivateEndpointId for Client.GetReversePrivateEndpoint +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) ExpectReversePrivateEndpointIdParam3(reversePrivateEndpointId string) *mClientMockGetReversePrivateEndpoint { + if mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpoint != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Set") + } + + if mmGetReversePrivateEndpoint.defaultExpectation == nil { + mmGetReversePrivateEndpoint.defaultExpectation = &ClientMockGetReversePrivateEndpointExpectation{} + } + + if mmGetReversePrivateEndpoint.defaultExpectation.params != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Expect") + } + + if mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs == nil { + mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs = &ClientMockGetReversePrivateEndpointParamPtrs{} + } + mmGetReversePrivateEndpoint.defaultExpectation.paramPtrs.reversePrivateEndpointId = &reversePrivateEndpointId + mmGetReversePrivateEndpoint.defaultExpectation.expectationOrigins.originReversePrivateEndpointId = minimock.CallerInfo(1) + + return mmGetReversePrivateEndpoint +} + +// Inspect accepts an inspector function that has same arguments as the Client.GetReversePrivateEndpoint +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) Inspect(f func(ctx context.Context, serviceId string, reversePrivateEndpointId string)) *mClientMockGetReversePrivateEndpoint { + if mmGetReversePrivateEndpoint.mock.inspectFuncGetReversePrivateEndpoint != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("Inspect function is already set for ClientMock.GetReversePrivateEndpoint") + } + + mmGetReversePrivateEndpoint.mock.inspectFuncGetReversePrivateEndpoint = f + + return mmGetReversePrivateEndpoint +} + +// Return sets up results that will be returned by Client.GetReversePrivateEndpoint +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) Return(rp1 *ReversePrivateEndpoint, err error) *ClientMock { + if mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpoint != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Set") + } + + if mmGetReversePrivateEndpoint.defaultExpectation == nil { + mmGetReversePrivateEndpoint.defaultExpectation = &ClientMockGetReversePrivateEndpointExpectation{mock: mmGetReversePrivateEndpoint.mock} + } + mmGetReversePrivateEndpoint.defaultExpectation.results = &ClientMockGetReversePrivateEndpointResults{rp1, err} + mmGetReversePrivateEndpoint.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetReversePrivateEndpoint.mock +} + +// Set uses given function f to mock the Client.GetReversePrivateEndpoint method +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) Set(f func(ctx context.Context, serviceId string, reversePrivateEndpointId string) (rp1 *ReversePrivateEndpoint, err error)) *ClientMock { + if mmGetReversePrivateEndpoint.defaultExpectation != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("Default expectation is already set for the Client.GetReversePrivateEndpoint method") + } + + if len(mmGetReversePrivateEndpoint.expectations) > 0 { + mmGetReversePrivateEndpoint.mock.t.Fatalf("Some expectations are already set for the Client.GetReversePrivateEndpoint method") + } + + mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpoint = f + mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpointOrigin = minimock.CallerInfo(1) + return mmGetReversePrivateEndpoint.mock +} + +// When sets expectation for the Client.GetReversePrivateEndpoint which will trigger the result defined by the following +// Then helper +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) When(ctx context.Context, serviceId string, reversePrivateEndpointId string) *ClientMockGetReversePrivateEndpointExpectation { + if mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpoint != nil { + mmGetReversePrivateEndpoint.mock.t.Fatalf("ClientMock.GetReversePrivateEndpoint mock is already set by Set") + } + + expectation := &ClientMockGetReversePrivateEndpointExpectation{ + mock: mmGetReversePrivateEndpoint.mock, + params: &ClientMockGetReversePrivateEndpointParams{ctx, serviceId, reversePrivateEndpointId}, + expectationOrigins: ClientMockGetReversePrivateEndpointExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmGetReversePrivateEndpoint.expectations = append(mmGetReversePrivateEndpoint.expectations, expectation) + return expectation +} + +// Then sets up Client.GetReversePrivateEndpoint return parameters for the expectation previously defined by the When method +func (e *ClientMockGetReversePrivateEndpointExpectation) Then(rp1 *ReversePrivateEndpoint, err error) *ClientMock { + e.results = &ClientMockGetReversePrivateEndpointResults{rp1, err} + return e.mock +} + +// Times sets number of times Client.GetReversePrivateEndpoint should be invoked +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) Times(n uint64) *mClientMockGetReversePrivateEndpoint { + if n == 0 { + mmGetReversePrivateEndpoint.mock.t.Fatalf("Times of ClientMock.GetReversePrivateEndpoint mock can not be zero") + } + mm_atomic.StoreUint64(&mmGetReversePrivateEndpoint.expectedInvocations, n) + mmGetReversePrivateEndpoint.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetReversePrivateEndpoint +} + +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) invocationsDone() bool { + if len(mmGetReversePrivateEndpoint.expectations) == 0 && mmGetReversePrivateEndpoint.defaultExpectation == nil && mmGetReversePrivateEndpoint.mock.funcGetReversePrivateEndpoint == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmGetReversePrivateEndpoint.mock.afterGetReversePrivateEndpointCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetReversePrivateEndpoint.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// GetReversePrivateEndpoint implements Client +func (mmGetReversePrivateEndpoint *ClientMock) GetReversePrivateEndpoint(ctx context.Context, serviceId string, reversePrivateEndpointId string) (rp1 *ReversePrivateEndpoint, err error) { + mm_atomic.AddUint64(&mmGetReversePrivateEndpoint.beforeGetReversePrivateEndpointCounter, 1) + defer mm_atomic.AddUint64(&mmGetReversePrivateEndpoint.afterGetReversePrivateEndpointCounter, 1) + + mmGetReversePrivateEndpoint.t.Helper() + + if mmGetReversePrivateEndpoint.inspectFuncGetReversePrivateEndpoint != nil { + mmGetReversePrivateEndpoint.inspectFuncGetReversePrivateEndpoint(ctx, serviceId, reversePrivateEndpointId) + } + + mm_params := ClientMockGetReversePrivateEndpointParams{ctx, serviceId, reversePrivateEndpointId} + + // Record call args + mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.mutex.Lock() + mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.callArgs = append(mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.callArgs, &mm_params) + mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.mutex.Unlock() + + for _, e := range mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.rp1, e.results.err + } + } + + if mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation.Counter, 1) + mm_want := mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation.params + mm_want_ptrs := mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation.paramPtrs + + mm_got := ClientMockGetReversePrivateEndpointParams{ctx, serviceId, reversePrivateEndpointId} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmGetReversePrivateEndpoint.t.Errorf("ClientMock.GetReversePrivateEndpoint got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { + mmGetReversePrivateEndpoint.t.Errorf("ClientMock.GetReversePrivateEndpoint got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + } + + if mm_want_ptrs.reversePrivateEndpointId != nil && !minimock.Equal(*mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId) { + mmGetReversePrivateEndpoint.t.Errorf("ClientMock.GetReversePrivateEndpoint got unexpected parameter reversePrivateEndpointId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation.expectationOrigins.originReversePrivateEndpointId, *mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId, minimock.Diff(*mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmGetReversePrivateEndpoint.t.Errorf("ClientMock.GetReversePrivateEndpoint got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmGetReversePrivateEndpoint.GetReversePrivateEndpointMock.defaultExpectation.results + if mm_results == nil { + mmGetReversePrivateEndpoint.t.Fatal("No results are set for the ClientMock.GetReversePrivateEndpoint") + } + return (*mm_results).rp1, (*mm_results).err + } + if mmGetReversePrivateEndpoint.funcGetReversePrivateEndpoint != nil { + return mmGetReversePrivateEndpoint.funcGetReversePrivateEndpoint(ctx, serviceId, reversePrivateEndpointId) + } + mmGetReversePrivateEndpoint.t.Fatalf("Unexpected call to ClientMock.GetReversePrivateEndpoint. %v %v %v", ctx, serviceId, reversePrivateEndpointId) + return +} + +// GetReversePrivateEndpointAfterCounter returns a count of finished ClientMock.GetReversePrivateEndpoint invocations +func (mmGetReversePrivateEndpoint *ClientMock) GetReversePrivateEndpointAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetReversePrivateEndpoint.afterGetReversePrivateEndpointCounter) +} + +// GetReversePrivateEndpointBeforeCounter returns a count of ClientMock.GetReversePrivateEndpoint invocations +func (mmGetReversePrivateEndpoint *ClientMock) GetReversePrivateEndpointBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetReversePrivateEndpoint.beforeGetReversePrivateEndpointCounter) +} + +// Calls returns a list of arguments used in each call to ClientMock.GetReversePrivateEndpoint. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmGetReversePrivateEndpoint *mClientMockGetReversePrivateEndpoint) Calls() []*ClientMockGetReversePrivateEndpointParams { + mmGetReversePrivateEndpoint.mutex.RLock() + + argCopy := make([]*ClientMockGetReversePrivateEndpointParams, len(mmGetReversePrivateEndpoint.callArgs)) + copy(argCopy, mmGetReversePrivateEndpoint.callArgs) + + mmGetReversePrivateEndpoint.mutex.RUnlock() + + return argCopy +} + +// MinimockGetReversePrivateEndpointDone returns true if the count of the GetReversePrivateEndpoint invocations corresponds +// the number of defined expectations +func (m *ClientMock) MinimockGetReversePrivateEndpointDone() bool { + if m.GetReversePrivateEndpointMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.GetReversePrivateEndpointMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.GetReversePrivateEndpointMock.invocationsDone() +} + +// MinimockGetReversePrivateEndpointInspect logs each unmet expectation +func (m *ClientMock) MinimockGetReversePrivateEndpointInspect() { + for _, e := range m.GetReversePrivateEndpointMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to ClientMock.GetReversePrivateEndpoint at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterGetReversePrivateEndpointCounter := mm_atomic.LoadUint64(&m.afterGetReversePrivateEndpointCounter) + // if default expectation was set then invocations count should be greater than zero + if m.GetReversePrivateEndpointMock.defaultExpectation != nil && afterGetReversePrivateEndpointCounter < 1 { + if m.GetReversePrivateEndpointMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to ClientMock.GetReversePrivateEndpoint at\n%s", m.GetReversePrivateEndpointMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to ClientMock.GetReversePrivateEndpoint at\n%s with params: %#v", m.GetReversePrivateEndpointMock.defaultExpectation.expectationOrigins.origin, *m.GetReversePrivateEndpointMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcGetReversePrivateEndpoint != nil && afterGetReversePrivateEndpointCounter < 1 { + m.t.Errorf("Expected call to ClientMock.GetReversePrivateEndpoint at\n%s", m.funcGetReversePrivateEndpointOrigin) + } + + if !m.GetReversePrivateEndpointMock.invocationsDone() && afterGetReversePrivateEndpointCounter > 0 { + m.t.Errorf("Expected %d calls to ClientMock.GetReversePrivateEndpoint at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetReversePrivateEndpointMock.expectedInvocations), m.GetReversePrivateEndpointMock.expectedInvocationsOrigin, afterGetReversePrivateEndpointCounter) + } +} + +type mClientMockGetReversePrivateEndpointPath struct { + optional bool + mock *ClientMock + defaultExpectation *ClientMockGetReversePrivateEndpointPathExpectation + expectations []*ClientMockGetReversePrivateEndpointPathExpectation + + callArgs []*ClientMockGetReversePrivateEndpointPathParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// ClientMockGetReversePrivateEndpointPathExpectation specifies expectation struct of the Client.GetReversePrivateEndpointPath +type ClientMockGetReversePrivateEndpointPathExpectation struct { + mock *ClientMock + params *ClientMockGetReversePrivateEndpointPathParams + paramPtrs *ClientMockGetReversePrivateEndpointPathParamPtrs + expectationOrigins ClientMockGetReversePrivateEndpointPathExpectationOrigins + results *ClientMockGetReversePrivateEndpointPathResults + returnOrigin string + Counter uint64 +} + +// ClientMockGetReversePrivateEndpointPathParams contains parameters of the Client.GetReversePrivateEndpointPath +type ClientMockGetReversePrivateEndpointPathParams struct { + serviceId string + reversePrivateEndpointId string +} + +// ClientMockGetReversePrivateEndpointPathParamPtrs contains pointers to parameters of the Client.GetReversePrivateEndpointPath +type ClientMockGetReversePrivateEndpointPathParamPtrs struct { + serviceId *string + reversePrivateEndpointId *string +} + +// ClientMockGetReversePrivateEndpointPathResults contains results of the Client.GetReversePrivateEndpointPath +type ClientMockGetReversePrivateEndpointPathResults struct { + s1 string +} + +// ClientMockGetReversePrivateEndpointPathOrigins contains origins of expectations of the Client.GetReversePrivateEndpointPath +type ClientMockGetReversePrivateEndpointPathExpectationOrigins struct { + origin string + originServiceId string + originReversePrivateEndpointId string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) Optional() *mClientMockGetReversePrivateEndpointPath { + mmGetReversePrivateEndpointPath.optional = true + return mmGetReversePrivateEndpointPath +} + +// Expect sets up expected params for Client.GetReversePrivateEndpointPath +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) Expect(serviceId string, reversePrivateEndpointId string) *mClientMockGetReversePrivateEndpointPath { + if mmGetReversePrivateEndpointPath.mock.funcGetReversePrivateEndpointPath != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("ClientMock.GetReversePrivateEndpointPath mock is already set by Set") + } + + if mmGetReversePrivateEndpointPath.defaultExpectation == nil { + mmGetReversePrivateEndpointPath.defaultExpectation = &ClientMockGetReversePrivateEndpointPathExpectation{} + } + + if mmGetReversePrivateEndpointPath.defaultExpectation.paramPtrs != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("ClientMock.GetReversePrivateEndpointPath mock is already set by ExpectParams functions") + } + + mmGetReversePrivateEndpointPath.defaultExpectation.params = &ClientMockGetReversePrivateEndpointPathParams{serviceId, reversePrivateEndpointId} + mmGetReversePrivateEndpointPath.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmGetReversePrivateEndpointPath.expectations { + if minimock.Equal(e.params, mmGetReversePrivateEndpointPath.defaultExpectation.params) { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetReversePrivateEndpointPath.defaultExpectation.params) + } + } + + return mmGetReversePrivateEndpointPath +} + +// ExpectServiceIdParam1 sets up expected param serviceId for Client.GetReversePrivateEndpointPath +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) ExpectServiceIdParam1(serviceId string) *mClientMockGetReversePrivateEndpointPath { + if mmGetReversePrivateEndpointPath.mock.funcGetReversePrivateEndpointPath != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("ClientMock.GetReversePrivateEndpointPath mock is already set by Set") + } + + if mmGetReversePrivateEndpointPath.defaultExpectation == nil { + mmGetReversePrivateEndpointPath.defaultExpectation = &ClientMockGetReversePrivateEndpointPathExpectation{} + } + + if mmGetReversePrivateEndpointPath.defaultExpectation.params != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("ClientMock.GetReversePrivateEndpointPath mock is already set by Expect") + } + + if mmGetReversePrivateEndpointPath.defaultExpectation.paramPtrs == nil { + mmGetReversePrivateEndpointPath.defaultExpectation.paramPtrs = &ClientMockGetReversePrivateEndpointPathParamPtrs{} + } + mmGetReversePrivateEndpointPath.defaultExpectation.paramPtrs.serviceId = &serviceId + mmGetReversePrivateEndpointPath.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) + + return mmGetReversePrivateEndpointPath +} + +// ExpectReversePrivateEndpointIdParam2 sets up expected param reversePrivateEndpointId for Client.GetReversePrivateEndpointPath +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) ExpectReversePrivateEndpointIdParam2(reversePrivateEndpointId string) *mClientMockGetReversePrivateEndpointPath { + if mmGetReversePrivateEndpointPath.mock.funcGetReversePrivateEndpointPath != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("ClientMock.GetReversePrivateEndpointPath mock is already set by Set") + } + + if mmGetReversePrivateEndpointPath.defaultExpectation == nil { + mmGetReversePrivateEndpointPath.defaultExpectation = &ClientMockGetReversePrivateEndpointPathExpectation{} + } + + if mmGetReversePrivateEndpointPath.defaultExpectation.params != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("ClientMock.GetReversePrivateEndpointPath mock is already set by Expect") + } + + if mmGetReversePrivateEndpointPath.defaultExpectation.paramPtrs == nil { + mmGetReversePrivateEndpointPath.defaultExpectation.paramPtrs = &ClientMockGetReversePrivateEndpointPathParamPtrs{} + } + mmGetReversePrivateEndpointPath.defaultExpectation.paramPtrs.reversePrivateEndpointId = &reversePrivateEndpointId + mmGetReversePrivateEndpointPath.defaultExpectation.expectationOrigins.originReversePrivateEndpointId = minimock.CallerInfo(1) + + return mmGetReversePrivateEndpointPath +} + +// Inspect accepts an inspector function that has same arguments as the Client.GetReversePrivateEndpointPath +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) Inspect(f func(serviceId string, reversePrivateEndpointId string)) *mClientMockGetReversePrivateEndpointPath { + if mmGetReversePrivateEndpointPath.mock.inspectFuncGetReversePrivateEndpointPath != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("Inspect function is already set for ClientMock.GetReversePrivateEndpointPath") + } + + mmGetReversePrivateEndpointPath.mock.inspectFuncGetReversePrivateEndpointPath = f + + return mmGetReversePrivateEndpointPath +} + +// Return sets up results that will be returned by Client.GetReversePrivateEndpointPath +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) Return(s1 string) *ClientMock { + if mmGetReversePrivateEndpointPath.mock.funcGetReversePrivateEndpointPath != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("ClientMock.GetReversePrivateEndpointPath mock is already set by Set") + } + + if mmGetReversePrivateEndpointPath.defaultExpectation == nil { + mmGetReversePrivateEndpointPath.defaultExpectation = &ClientMockGetReversePrivateEndpointPathExpectation{mock: mmGetReversePrivateEndpointPath.mock} + } + mmGetReversePrivateEndpointPath.defaultExpectation.results = &ClientMockGetReversePrivateEndpointPathResults{s1} + mmGetReversePrivateEndpointPath.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmGetReversePrivateEndpointPath.mock +} + +// Set uses given function f to mock the Client.GetReversePrivateEndpointPath method +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) Set(f func(serviceId string, reversePrivateEndpointId string) (s1 string)) *ClientMock { + if mmGetReversePrivateEndpointPath.defaultExpectation != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("Default expectation is already set for the Client.GetReversePrivateEndpointPath method") + } + + if len(mmGetReversePrivateEndpointPath.expectations) > 0 { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("Some expectations are already set for the Client.GetReversePrivateEndpointPath method") + } + + mmGetReversePrivateEndpointPath.mock.funcGetReversePrivateEndpointPath = f + mmGetReversePrivateEndpointPath.mock.funcGetReversePrivateEndpointPathOrigin = minimock.CallerInfo(1) + return mmGetReversePrivateEndpointPath.mock +} + +// When sets expectation for the Client.GetReversePrivateEndpointPath which will trigger the result defined by the following +// Then helper +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) When(serviceId string, reversePrivateEndpointId string) *ClientMockGetReversePrivateEndpointPathExpectation { + if mmGetReversePrivateEndpointPath.mock.funcGetReversePrivateEndpointPath != nil { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("ClientMock.GetReversePrivateEndpointPath mock is already set by Set") + } + + expectation := &ClientMockGetReversePrivateEndpointPathExpectation{ + mock: mmGetReversePrivateEndpointPath.mock, + params: &ClientMockGetReversePrivateEndpointPathParams{serviceId, reversePrivateEndpointId}, + expectationOrigins: ClientMockGetReversePrivateEndpointPathExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmGetReversePrivateEndpointPath.expectations = append(mmGetReversePrivateEndpointPath.expectations, expectation) + return expectation +} + +// Then sets up Client.GetReversePrivateEndpointPath return parameters for the expectation previously defined by the When method +func (e *ClientMockGetReversePrivateEndpointPathExpectation) Then(s1 string) *ClientMock { + e.results = &ClientMockGetReversePrivateEndpointPathResults{s1} + return e.mock +} + +// Times sets number of times Client.GetReversePrivateEndpointPath should be invoked +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) Times(n uint64) *mClientMockGetReversePrivateEndpointPath { + if n == 0 { + mmGetReversePrivateEndpointPath.mock.t.Fatalf("Times of ClientMock.GetReversePrivateEndpointPath mock can not be zero") + } + mm_atomic.StoreUint64(&mmGetReversePrivateEndpointPath.expectedInvocations, n) + mmGetReversePrivateEndpointPath.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmGetReversePrivateEndpointPath +} + +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) invocationsDone() bool { + if len(mmGetReversePrivateEndpointPath.expectations) == 0 && mmGetReversePrivateEndpointPath.defaultExpectation == nil && mmGetReversePrivateEndpointPath.mock.funcGetReversePrivateEndpointPath == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmGetReversePrivateEndpointPath.mock.afterGetReversePrivateEndpointPathCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmGetReversePrivateEndpointPath.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// GetReversePrivateEndpointPath implements Client +func (mmGetReversePrivateEndpointPath *ClientMock) GetReversePrivateEndpointPath(serviceId string, reversePrivateEndpointId string) (s1 string) { + mm_atomic.AddUint64(&mmGetReversePrivateEndpointPath.beforeGetReversePrivateEndpointPathCounter, 1) + defer mm_atomic.AddUint64(&mmGetReversePrivateEndpointPath.afterGetReversePrivateEndpointPathCounter, 1) + + mmGetReversePrivateEndpointPath.t.Helper() + + if mmGetReversePrivateEndpointPath.inspectFuncGetReversePrivateEndpointPath != nil { + mmGetReversePrivateEndpointPath.inspectFuncGetReversePrivateEndpointPath(serviceId, reversePrivateEndpointId) + } + + mm_params := ClientMockGetReversePrivateEndpointPathParams{serviceId, reversePrivateEndpointId} + + // Record call args + mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.mutex.Lock() + mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.callArgs = append(mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.callArgs, &mm_params) + mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.mutex.Unlock() + + for _, e := range mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.s1 + } + } + + if mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.defaultExpectation.Counter, 1) + mm_want := mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.defaultExpectation.params + mm_want_ptrs := mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.defaultExpectation.paramPtrs + + mm_got := ClientMockGetReversePrivateEndpointPathParams{serviceId, reversePrivateEndpointId} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { + mmGetReversePrivateEndpointPath.t.Errorf("ClientMock.GetReversePrivateEndpointPath got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + } + + if mm_want_ptrs.reversePrivateEndpointId != nil && !minimock.Equal(*mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId) { + mmGetReversePrivateEndpointPath.t.Errorf("ClientMock.GetReversePrivateEndpointPath got unexpected parameter reversePrivateEndpointId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.defaultExpectation.expectationOrigins.originReversePrivateEndpointId, *mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId, minimock.Diff(*mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmGetReversePrivateEndpointPath.t.Errorf("ClientMock.GetReversePrivateEndpointPath got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmGetReversePrivateEndpointPath.GetReversePrivateEndpointPathMock.defaultExpectation.results + if mm_results == nil { + mmGetReversePrivateEndpointPath.t.Fatal("No results are set for the ClientMock.GetReversePrivateEndpointPath") + } + return (*mm_results).s1 + } + if mmGetReversePrivateEndpointPath.funcGetReversePrivateEndpointPath != nil { + return mmGetReversePrivateEndpointPath.funcGetReversePrivateEndpointPath(serviceId, reversePrivateEndpointId) + } + mmGetReversePrivateEndpointPath.t.Fatalf("Unexpected call to ClientMock.GetReversePrivateEndpointPath. %v %v", serviceId, reversePrivateEndpointId) + return +} + +// GetReversePrivateEndpointPathAfterCounter returns a count of finished ClientMock.GetReversePrivateEndpointPath invocations +func (mmGetReversePrivateEndpointPath *ClientMock) GetReversePrivateEndpointPathAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetReversePrivateEndpointPath.afterGetReversePrivateEndpointPathCounter) +} + +// GetReversePrivateEndpointPathBeforeCounter returns a count of ClientMock.GetReversePrivateEndpointPath invocations +func (mmGetReversePrivateEndpointPath *ClientMock) GetReversePrivateEndpointPathBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmGetReversePrivateEndpointPath.beforeGetReversePrivateEndpointPathCounter) +} + +// Calls returns a list of arguments used in each call to ClientMock.GetReversePrivateEndpointPath. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmGetReversePrivateEndpointPath *mClientMockGetReversePrivateEndpointPath) Calls() []*ClientMockGetReversePrivateEndpointPathParams { + mmGetReversePrivateEndpointPath.mutex.RLock() + + argCopy := make([]*ClientMockGetReversePrivateEndpointPathParams, len(mmGetReversePrivateEndpointPath.callArgs)) + copy(argCopy, mmGetReversePrivateEndpointPath.callArgs) + + mmGetReversePrivateEndpointPath.mutex.RUnlock() + + return argCopy +} + +// MinimockGetReversePrivateEndpointPathDone returns true if the count of the GetReversePrivateEndpointPath invocations corresponds +// the number of defined expectations +func (m *ClientMock) MinimockGetReversePrivateEndpointPathDone() bool { + if m.GetReversePrivateEndpointPathMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.GetReversePrivateEndpointPathMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.GetReversePrivateEndpointPathMock.invocationsDone() +} + +// MinimockGetReversePrivateEndpointPathInspect logs each unmet expectation +func (m *ClientMock) MinimockGetReversePrivateEndpointPathInspect() { + for _, e := range m.GetReversePrivateEndpointPathMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to ClientMock.GetReversePrivateEndpointPath at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterGetReversePrivateEndpointPathCounter := mm_atomic.LoadUint64(&m.afterGetReversePrivateEndpointPathCounter) + // if default expectation was set then invocations count should be greater than zero + if m.GetReversePrivateEndpointPathMock.defaultExpectation != nil && afterGetReversePrivateEndpointPathCounter < 1 { + if m.GetReversePrivateEndpointPathMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to ClientMock.GetReversePrivateEndpointPath at\n%s", m.GetReversePrivateEndpointPathMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to ClientMock.GetReversePrivateEndpointPath at\n%s with params: %#v", m.GetReversePrivateEndpointPathMock.defaultExpectation.expectationOrigins.origin, *m.GetReversePrivateEndpointPathMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcGetReversePrivateEndpointPath != nil && afterGetReversePrivateEndpointPathCounter < 1 { + m.t.Errorf("Expected call to ClientMock.GetReversePrivateEndpointPath at\n%s", m.funcGetReversePrivateEndpointPathOrigin) + } + + if !m.GetReversePrivateEndpointPathMock.invocationsDone() && afterGetReversePrivateEndpointPathCounter > 0 { + m.t.Errorf("Expected %d calls to ClientMock.GetReversePrivateEndpointPath at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetReversePrivateEndpointPathMock.expectedInvocations), m.GetReversePrivateEndpointPathMock.expectedInvocationsOrigin, afterGetReversePrivateEndpointPathCounter) + } +} + +type mClientMockGetRole struct { + optional bool + mock *ClientMock + defaultExpectation *ClientMockGetRoleExpectation + expectations []*ClientMockGetRoleExpectation + + callArgs []*ClientMockGetRoleParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// ClientMockGetRoleExpectation specifies expectation struct of the Client.GetRole +type ClientMockGetRoleExpectation struct { + mock *ClientMock + params *ClientMockGetRoleParams + paramPtrs *ClientMockGetRoleParamPtrs + expectationOrigins ClientMockGetRoleExpectationOrigins + results *ClientMockGetRoleResults + returnOrigin string + Counter uint64 +} + +// ClientMockGetRoleParams contains parameters of the Client.GetRole +type ClientMockGetRoleParams struct { + ctx context.Context + serviceID string + name string +} + +// ClientMockGetRoleParamPtrs contains pointers to parameters of the Client.GetRole +type ClientMockGetRoleParamPtrs struct { + ctx *context.Context serviceID *string name *string } @@ -8097,6 +10212,14 @@ type ClientMockGetRoleResults struct { err error } +// ClientMockGetRoleOrigins contains origins of expectations of the Client.GetRole +type ClientMockGetRoleExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -8122,6 +10245,7 @@ func (mmGetRole *mClientMockGetRole) Expect(ctx context.Context, serviceID strin } mmGetRole.defaultExpectation.params = &ClientMockGetRoleParams{ctx, serviceID, name} + mmGetRole.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetRole.expectations { if minimock.Equal(e.params, mmGetRole.defaultExpectation.params) { mmGetRole.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetRole.defaultExpectation.params) @@ -8149,6 +10273,7 @@ func (mmGetRole *mClientMockGetRole) ExpectCtxParam1(ctx context.Context) *mClie mmGetRole.defaultExpectation.paramPtrs = &ClientMockGetRoleParamPtrs{} } mmGetRole.defaultExpectation.paramPtrs.ctx = &ctx + mmGetRole.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetRole } @@ -8171,6 +10296,7 @@ func (mmGetRole *mClientMockGetRole) ExpectServiceIDParam2(serviceID string) *mC mmGetRole.defaultExpectation.paramPtrs = &ClientMockGetRoleParamPtrs{} } mmGetRole.defaultExpectation.paramPtrs.serviceID = &serviceID + mmGetRole.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmGetRole } @@ -8193,6 +10319,7 @@ func (mmGetRole *mClientMockGetRole) ExpectNameParam3(name string) *mClientMockG mmGetRole.defaultExpectation.paramPtrs = &ClientMockGetRoleParamPtrs{} } mmGetRole.defaultExpectation.paramPtrs.name = &name + mmGetRole.defaultExpectation.expectationOrigins.originName = minimock.CallerInfo(1) return mmGetRole } @@ -8218,6 +10345,7 @@ func (mmGetRole *mClientMockGetRole) Return(rp1 *Role, err error) *ClientMock { mmGetRole.defaultExpectation = &ClientMockGetRoleExpectation{mock: mmGetRole.mock} } mmGetRole.defaultExpectation.results = &ClientMockGetRoleResults{rp1, err} + mmGetRole.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetRole.mock } @@ -8232,6 +10360,7 @@ func (mmGetRole *mClientMockGetRole) Set(f func(ctx context.Context, serviceID s } mmGetRole.mock.funcGetRole = f + mmGetRole.mock.funcGetRoleOrigin = minimock.CallerInfo(1) return mmGetRole.mock } @@ -8243,8 +10372,9 @@ func (mmGetRole *mClientMockGetRole) When(ctx context.Context, serviceID string, } expectation := &ClientMockGetRoleExpectation{ - mock: mmGetRole.mock, - params: &ClientMockGetRoleParams{ctx, serviceID, name}, + mock: mmGetRole.mock, + params: &ClientMockGetRoleParams{ctx, serviceID, name}, + expectationOrigins: ClientMockGetRoleExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetRole.expectations = append(mmGetRole.expectations, expectation) return expectation @@ -8262,6 +10392,7 @@ func (mmGetRole *mClientMockGetRole) Times(n uint64) *mClientMockGetRole { mmGetRole.mock.t.Fatalf("Times of ClientMock.GetRole mock can not be zero") } mm_atomic.StoreUint64(&mmGetRole.expectedInvocations, n) + mmGetRole.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetRole } @@ -8281,6 +10412,8 @@ func (mmGetRole *ClientMock) GetRole(ctx context.Context, serviceID string, name mm_atomic.AddUint64(&mmGetRole.beforeGetRoleCounter, 1) defer mm_atomic.AddUint64(&mmGetRole.afterGetRoleCounter, 1) + mmGetRole.t.Helper() + if mmGetRole.inspectFuncGetRole != nil { mmGetRole.inspectFuncGetRole(ctx, serviceID, name) } @@ -8309,19 +10442,23 @@ func (mmGetRole *ClientMock) GetRole(ctx context.Context, serviceID string, name if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetRole.t.Errorf("ClientMock.GetRole got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetRole.t.Errorf("ClientMock.GetRole got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetRole.GetRoleMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmGetRole.t.Errorf("ClientMock.GetRole got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmGetRole.t.Errorf("ClientMock.GetRole got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetRole.GetRoleMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.name != nil && !minimock.Equal(*mm_want_ptrs.name, mm_got.name) { - mmGetRole.t.Errorf("ClientMock.GetRole got unexpected parameter name, want: %#v, got: %#v%s\n", *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) + mmGetRole.t.Errorf("ClientMock.GetRole got unexpected parameter name, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetRole.GetRoleMock.defaultExpectation.expectationOrigins.originName, *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetRole.t.Errorf("ClientMock.GetRole got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetRole.t.Errorf("ClientMock.GetRole got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetRole.GetRoleMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetRole.GetRoleMock.defaultExpectation.results @@ -8381,7 +10518,7 @@ func (m *ClientMock) MinimockGetRoleDone() bool { func (m *ClientMock) MinimockGetRoleInspect() { for _, e := range m.GetRoleMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetRole with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetRole at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -8389,19 +10526,19 @@ func (m *ClientMock) MinimockGetRoleInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetRoleMock.defaultExpectation != nil && afterGetRoleCounter < 1 { if m.GetRoleMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetRole") + m.t.Errorf("Expected call to ClientMock.GetRole at\n%s", m.GetRoleMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetRole with params: %#v", *m.GetRoleMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetRole at\n%s with params: %#v", m.GetRoleMock.defaultExpectation.expectationOrigins.origin, *m.GetRoleMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetRole != nil && afterGetRoleCounter < 1 { - m.t.Error("Expected call to ClientMock.GetRole") + m.t.Errorf("Expected call to ClientMock.GetRole at\n%s", m.funcGetRoleOrigin) } if !m.GetRoleMock.invocationsDone() && afterGetRoleCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetRole but found %d calls", - mm_atomic.LoadUint64(&m.GetRoleMock.expectedInvocations), afterGetRoleCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetRole at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetRoleMock.expectedInvocations), m.GetRoleMock.expectedInvocationsOrigin, afterGetRoleCounter) } } @@ -8414,16 +10551,19 @@ type mClientMockGetService struct { callArgs []*ClientMockGetServiceParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetServiceExpectation specifies expectation struct of the Client.GetService type ClientMockGetServiceExpectation struct { - mock *ClientMock - params *ClientMockGetServiceParams - paramPtrs *ClientMockGetServiceParamPtrs - results *ClientMockGetServiceResults - Counter uint64 + mock *ClientMock + params *ClientMockGetServiceParams + paramPtrs *ClientMockGetServiceParamPtrs + expectationOrigins ClientMockGetServiceExpectationOrigins + results *ClientMockGetServiceResults + returnOrigin string + Counter uint64 } // ClientMockGetServiceParams contains parameters of the Client.GetService @@ -8444,6 +10584,13 @@ type ClientMockGetServiceResults struct { err error } +// ClientMockGetServiceOrigins contains origins of expectations of the Client.GetService +type ClientMockGetServiceExpectationOrigins struct { + origin string + originCtx string + originServiceId string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -8469,6 +10616,7 @@ func (mmGetService *mClientMockGetService) Expect(ctx context.Context, serviceId } mmGetService.defaultExpectation.params = &ClientMockGetServiceParams{ctx, serviceId} + mmGetService.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetService.expectations { if minimock.Equal(e.params, mmGetService.defaultExpectation.params) { mmGetService.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetService.defaultExpectation.params) @@ -8496,6 +10644,7 @@ func (mmGetService *mClientMockGetService) ExpectCtxParam1(ctx context.Context) mmGetService.defaultExpectation.paramPtrs = &ClientMockGetServiceParamPtrs{} } mmGetService.defaultExpectation.paramPtrs.ctx = &ctx + mmGetService.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetService } @@ -8518,6 +10667,7 @@ func (mmGetService *mClientMockGetService) ExpectServiceIdParam2(serviceId strin mmGetService.defaultExpectation.paramPtrs = &ClientMockGetServiceParamPtrs{} } mmGetService.defaultExpectation.paramPtrs.serviceId = &serviceId + mmGetService.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmGetService } @@ -8543,6 +10693,7 @@ func (mmGetService *mClientMockGetService) Return(sp1 *Service, err error) *Clie mmGetService.defaultExpectation = &ClientMockGetServiceExpectation{mock: mmGetService.mock} } mmGetService.defaultExpectation.results = &ClientMockGetServiceResults{sp1, err} + mmGetService.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetService.mock } @@ -8557,6 +10708,7 @@ func (mmGetService *mClientMockGetService) Set(f func(ctx context.Context, servi } mmGetService.mock.funcGetService = f + mmGetService.mock.funcGetServiceOrigin = minimock.CallerInfo(1) return mmGetService.mock } @@ -8568,8 +10720,9 @@ func (mmGetService *mClientMockGetService) When(ctx context.Context, serviceId s } expectation := &ClientMockGetServiceExpectation{ - mock: mmGetService.mock, - params: &ClientMockGetServiceParams{ctx, serviceId}, + mock: mmGetService.mock, + params: &ClientMockGetServiceParams{ctx, serviceId}, + expectationOrigins: ClientMockGetServiceExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetService.expectations = append(mmGetService.expectations, expectation) return expectation @@ -8587,6 +10740,7 @@ func (mmGetService *mClientMockGetService) Times(n uint64) *mClientMockGetServic mmGetService.mock.t.Fatalf("Times of ClientMock.GetService mock can not be zero") } mm_atomic.StoreUint64(&mmGetService.expectedInvocations, n) + mmGetService.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetService } @@ -8606,6 +10760,8 @@ func (mmGetService *ClientMock) GetService(ctx context.Context, serviceId string mm_atomic.AddUint64(&mmGetService.beforeGetServiceCounter, 1) defer mm_atomic.AddUint64(&mmGetService.afterGetServiceCounter, 1) + mmGetService.t.Helper() + if mmGetService.inspectFuncGetService != nil { mmGetService.inspectFuncGetService(ctx, serviceId) } @@ -8634,15 +10790,18 @@ func (mmGetService *ClientMock) GetService(ctx context.Context, serviceId string if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetService.t.Errorf("ClientMock.GetService got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetService.t.Errorf("ClientMock.GetService got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetService.GetServiceMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmGetService.t.Errorf("ClientMock.GetService got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmGetService.t.Errorf("ClientMock.GetService got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetService.GetServiceMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetService.t.Errorf("ClientMock.GetService got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetService.t.Errorf("ClientMock.GetService got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetService.GetServiceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetService.GetServiceMock.defaultExpectation.results @@ -8702,7 +10861,7 @@ func (m *ClientMock) MinimockGetServiceDone() bool { func (m *ClientMock) MinimockGetServiceInspect() { for _, e := range m.GetServiceMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetService with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetService at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -8710,19 +10869,19 @@ func (m *ClientMock) MinimockGetServiceInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetServiceMock.defaultExpectation != nil && afterGetServiceCounter < 1 { if m.GetServiceMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetService") + m.t.Errorf("Expected call to ClientMock.GetService at\n%s", m.GetServiceMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetService with params: %#v", *m.GetServiceMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetService at\n%s with params: %#v", m.GetServiceMock.defaultExpectation.expectationOrigins.origin, *m.GetServiceMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetService != nil && afterGetServiceCounter < 1 { - m.t.Error("Expected call to ClientMock.GetService") + m.t.Errorf("Expected call to ClientMock.GetService at\n%s", m.funcGetServiceOrigin) } if !m.GetServiceMock.invocationsDone() && afterGetServiceCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetService but found %d calls", - mm_atomic.LoadUint64(&m.GetServiceMock.expectedInvocations), afterGetServiceCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetService at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetServiceMock.expectedInvocations), m.GetServiceMock.expectedInvocationsOrigin, afterGetServiceCounter) } } @@ -8735,16 +10894,19 @@ type mClientMockGetUser struct { callArgs []*ClientMockGetUserParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGetUserExpectation specifies expectation struct of the Client.GetUser type ClientMockGetUserExpectation struct { - mock *ClientMock - params *ClientMockGetUserParams - paramPtrs *ClientMockGetUserParamPtrs - results *ClientMockGetUserResults - Counter uint64 + mock *ClientMock + params *ClientMockGetUserParams + paramPtrs *ClientMockGetUserParamPtrs + expectationOrigins ClientMockGetUserExpectationOrigins + results *ClientMockGetUserResults + returnOrigin string + Counter uint64 } // ClientMockGetUserParams contains parameters of the Client.GetUser @@ -8767,6 +10929,14 @@ type ClientMockGetUserResults struct { err error } +// ClientMockGetUserOrigins contains origins of expectations of the Client.GetUser +type ClientMockGetUserExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -8792,6 +10962,7 @@ func (mmGetUser *mClientMockGetUser) Expect(ctx context.Context, serviceID strin } mmGetUser.defaultExpectation.params = &ClientMockGetUserParams{ctx, serviceID, name} + mmGetUser.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGetUser.expectations { if minimock.Equal(e.params, mmGetUser.defaultExpectation.params) { mmGetUser.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetUser.defaultExpectation.params) @@ -8819,6 +10990,7 @@ func (mmGetUser *mClientMockGetUser) ExpectCtxParam1(ctx context.Context) *mClie mmGetUser.defaultExpectation.paramPtrs = &ClientMockGetUserParamPtrs{} } mmGetUser.defaultExpectation.paramPtrs.ctx = &ctx + mmGetUser.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGetUser } @@ -8841,6 +11013,7 @@ func (mmGetUser *mClientMockGetUser) ExpectServiceIDParam2(serviceID string) *mC mmGetUser.defaultExpectation.paramPtrs = &ClientMockGetUserParamPtrs{} } mmGetUser.defaultExpectation.paramPtrs.serviceID = &serviceID + mmGetUser.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmGetUser } @@ -8863,6 +11036,7 @@ func (mmGetUser *mClientMockGetUser) ExpectNameParam3(name string) *mClientMockG mmGetUser.defaultExpectation.paramPtrs = &ClientMockGetUserParamPtrs{} } mmGetUser.defaultExpectation.paramPtrs.name = &name + mmGetUser.defaultExpectation.expectationOrigins.originName = minimock.CallerInfo(1) return mmGetUser } @@ -8888,6 +11062,7 @@ func (mmGetUser *mClientMockGetUser) Return(up1 *User, err error) *ClientMock { mmGetUser.defaultExpectation = &ClientMockGetUserExpectation{mock: mmGetUser.mock} } mmGetUser.defaultExpectation.results = &ClientMockGetUserResults{up1, err} + mmGetUser.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGetUser.mock } @@ -8902,6 +11077,7 @@ func (mmGetUser *mClientMockGetUser) Set(f func(ctx context.Context, serviceID s } mmGetUser.mock.funcGetUser = f + mmGetUser.mock.funcGetUserOrigin = minimock.CallerInfo(1) return mmGetUser.mock } @@ -8913,8 +11089,9 @@ func (mmGetUser *mClientMockGetUser) When(ctx context.Context, serviceID string, } expectation := &ClientMockGetUserExpectation{ - mock: mmGetUser.mock, - params: &ClientMockGetUserParams{ctx, serviceID, name}, + mock: mmGetUser.mock, + params: &ClientMockGetUserParams{ctx, serviceID, name}, + expectationOrigins: ClientMockGetUserExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGetUser.expectations = append(mmGetUser.expectations, expectation) return expectation @@ -8932,6 +11109,7 @@ func (mmGetUser *mClientMockGetUser) Times(n uint64) *mClientMockGetUser { mmGetUser.mock.t.Fatalf("Times of ClientMock.GetUser mock can not be zero") } mm_atomic.StoreUint64(&mmGetUser.expectedInvocations, n) + mmGetUser.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGetUser } @@ -8951,6 +11129,8 @@ func (mmGetUser *ClientMock) GetUser(ctx context.Context, serviceID string, name mm_atomic.AddUint64(&mmGetUser.beforeGetUserCounter, 1) defer mm_atomic.AddUint64(&mmGetUser.afterGetUserCounter, 1) + mmGetUser.t.Helper() + if mmGetUser.inspectFuncGetUser != nil { mmGetUser.inspectFuncGetUser(ctx, serviceID, name) } @@ -8979,19 +11159,23 @@ func (mmGetUser *ClientMock) GetUser(ctx context.Context, serviceID string, name if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGetUser.t.Errorf("ClientMock.GetUser got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGetUser.t.Errorf("ClientMock.GetUser got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetUser.GetUserMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmGetUser.t.Errorf("ClientMock.GetUser got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmGetUser.t.Errorf("ClientMock.GetUser got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetUser.GetUserMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.name != nil && !minimock.Equal(*mm_want_ptrs.name, mm_got.name) { - mmGetUser.t.Errorf("ClientMock.GetUser got unexpected parameter name, want: %#v, got: %#v%s\n", *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) + mmGetUser.t.Errorf("ClientMock.GetUser got unexpected parameter name, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetUser.GetUserMock.defaultExpectation.expectationOrigins.originName, *mm_want_ptrs.name, mm_got.name, minimock.Diff(*mm_want_ptrs.name, mm_got.name)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGetUser.t.Errorf("ClientMock.GetUser got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGetUser.t.Errorf("ClientMock.GetUser got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGetUser.GetUserMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGetUser.GetUserMock.defaultExpectation.results @@ -9051,7 +11235,7 @@ func (m *ClientMock) MinimockGetUserDone() bool { func (m *ClientMock) MinimockGetUserInspect() { for _, e := range m.GetUserMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GetUser with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GetUser at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -9059,19 +11243,19 @@ func (m *ClientMock) MinimockGetUserInspect() { // if default expectation was set then invocations count should be greater than zero if m.GetUserMock.defaultExpectation != nil && afterGetUserCounter < 1 { if m.GetUserMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GetUser") + m.t.Errorf("Expected call to ClientMock.GetUser at\n%s", m.GetUserMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GetUser with params: %#v", *m.GetUserMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GetUser at\n%s with params: %#v", m.GetUserMock.defaultExpectation.expectationOrigins.origin, *m.GetUserMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGetUser != nil && afterGetUserCounter < 1 { - m.t.Error("Expected call to ClientMock.GetUser") + m.t.Errorf("Expected call to ClientMock.GetUser at\n%s", m.funcGetUserOrigin) } if !m.GetUserMock.invocationsDone() && afterGetUserCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GetUser but found %d calls", - mm_atomic.LoadUint64(&m.GetUserMock.expectedInvocations), afterGetUserCounter) + m.t.Errorf("Expected %d calls to ClientMock.GetUser at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GetUserMock.expectedInvocations), m.GetUserMock.expectedInvocationsOrigin, afterGetUserCounter) } } @@ -9084,16 +11268,19 @@ type mClientMockGrantPrivilege struct { callArgs []*ClientMockGrantPrivilegeParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGrantPrivilegeExpectation specifies expectation struct of the Client.GrantPrivilege type ClientMockGrantPrivilegeExpectation struct { - mock *ClientMock - params *ClientMockGrantPrivilegeParams - paramPtrs *ClientMockGrantPrivilegeParamPtrs - results *ClientMockGrantPrivilegeResults - Counter uint64 + mock *ClientMock + params *ClientMockGrantPrivilegeParams + paramPtrs *ClientMockGrantPrivilegeParamPtrs + expectationOrigins ClientMockGrantPrivilegeExpectationOrigins + results *ClientMockGrantPrivilegeResults + returnOrigin string + Counter uint64 } // ClientMockGrantPrivilegeParams contains parameters of the Client.GrantPrivilege @@ -9116,6 +11303,14 @@ type ClientMockGrantPrivilegeResults struct { err error } +// ClientMockGrantPrivilegeOrigins contains origins of expectations of the Client.GrantPrivilege +type ClientMockGrantPrivilegeExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originGrantPrivilege string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -9141,6 +11336,7 @@ func (mmGrantPrivilege *mClientMockGrantPrivilege) Expect(ctx context.Context, s } mmGrantPrivilege.defaultExpectation.params = &ClientMockGrantPrivilegeParams{ctx, serviceId, grantPrivilege} + mmGrantPrivilege.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGrantPrivilege.expectations { if minimock.Equal(e.params, mmGrantPrivilege.defaultExpectation.params) { mmGrantPrivilege.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGrantPrivilege.defaultExpectation.params) @@ -9168,6 +11364,7 @@ func (mmGrantPrivilege *mClientMockGrantPrivilege) ExpectCtxParam1(ctx context.C mmGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGrantPrivilegeParamPtrs{} } mmGrantPrivilege.defaultExpectation.paramPtrs.ctx = &ctx + mmGrantPrivilege.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGrantPrivilege } @@ -9190,6 +11387,7 @@ func (mmGrantPrivilege *mClientMockGrantPrivilege) ExpectServiceIdParam2(service mmGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGrantPrivilegeParamPtrs{} } mmGrantPrivilege.defaultExpectation.paramPtrs.serviceId = &serviceId + mmGrantPrivilege.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmGrantPrivilege } @@ -9212,6 +11410,7 @@ func (mmGrantPrivilege *mClientMockGrantPrivilege) ExpectGrantPrivilegeParam3(gr mmGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockGrantPrivilegeParamPtrs{} } mmGrantPrivilege.defaultExpectation.paramPtrs.grantPrivilege = &grantPrivilege + mmGrantPrivilege.defaultExpectation.expectationOrigins.originGrantPrivilege = minimock.CallerInfo(1) return mmGrantPrivilege } @@ -9237,6 +11436,7 @@ func (mmGrantPrivilege *mClientMockGrantPrivilege) Return(gp1 *GrantPrivilege, e mmGrantPrivilege.defaultExpectation = &ClientMockGrantPrivilegeExpectation{mock: mmGrantPrivilege.mock} } mmGrantPrivilege.defaultExpectation.results = &ClientMockGrantPrivilegeResults{gp1, err} + mmGrantPrivilege.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGrantPrivilege.mock } @@ -9251,6 +11451,7 @@ func (mmGrantPrivilege *mClientMockGrantPrivilege) Set(f func(ctx context.Contex } mmGrantPrivilege.mock.funcGrantPrivilege = f + mmGrantPrivilege.mock.funcGrantPrivilegeOrigin = minimock.CallerInfo(1) return mmGrantPrivilege.mock } @@ -9262,8 +11463,9 @@ func (mmGrantPrivilege *mClientMockGrantPrivilege) When(ctx context.Context, ser } expectation := &ClientMockGrantPrivilegeExpectation{ - mock: mmGrantPrivilege.mock, - params: &ClientMockGrantPrivilegeParams{ctx, serviceId, grantPrivilege}, + mock: mmGrantPrivilege.mock, + params: &ClientMockGrantPrivilegeParams{ctx, serviceId, grantPrivilege}, + expectationOrigins: ClientMockGrantPrivilegeExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGrantPrivilege.expectations = append(mmGrantPrivilege.expectations, expectation) return expectation @@ -9281,6 +11483,7 @@ func (mmGrantPrivilege *mClientMockGrantPrivilege) Times(n uint64) *mClientMockG mmGrantPrivilege.mock.t.Fatalf("Times of ClientMock.GrantPrivilege mock can not be zero") } mm_atomic.StoreUint64(&mmGrantPrivilege.expectedInvocations, n) + mmGrantPrivilege.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGrantPrivilege } @@ -9300,6 +11503,8 @@ func (mmGrantPrivilege *ClientMock) GrantPrivilege(ctx context.Context, serviceI mm_atomic.AddUint64(&mmGrantPrivilege.beforeGrantPrivilegeCounter, 1) defer mm_atomic.AddUint64(&mmGrantPrivilege.afterGrantPrivilegeCounter, 1) + mmGrantPrivilege.t.Helper() + if mmGrantPrivilege.inspectFuncGrantPrivilege != nil { mmGrantPrivilege.inspectFuncGrantPrivilege(ctx, serviceId, grantPrivilege) } @@ -9328,19 +11533,23 @@ func (mmGrantPrivilege *ClientMock) GrantPrivilege(ctx context.Context, serviceI if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGrantPrivilege.t.Errorf("ClientMock.GrantPrivilege got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGrantPrivilege.t.Errorf("ClientMock.GrantPrivilege got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGrantPrivilege.GrantPrivilegeMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmGrantPrivilege.t.Errorf("ClientMock.GrantPrivilege got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmGrantPrivilege.t.Errorf("ClientMock.GrantPrivilege got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGrantPrivilege.GrantPrivilegeMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.grantPrivilege != nil && !minimock.Equal(*mm_want_ptrs.grantPrivilege, mm_got.grantPrivilege) { - mmGrantPrivilege.t.Errorf("ClientMock.GrantPrivilege got unexpected parameter grantPrivilege, want: %#v, got: %#v%s\n", *mm_want_ptrs.grantPrivilege, mm_got.grantPrivilege, minimock.Diff(*mm_want_ptrs.grantPrivilege, mm_got.grantPrivilege)) + mmGrantPrivilege.t.Errorf("ClientMock.GrantPrivilege got unexpected parameter grantPrivilege, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGrantPrivilege.GrantPrivilegeMock.defaultExpectation.expectationOrigins.originGrantPrivilege, *mm_want_ptrs.grantPrivilege, mm_got.grantPrivilege, minimock.Diff(*mm_want_ptrs.grantPrivilege, mm_got.grantPrivilege)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGrantPrivilege.t.Errorf("ClientMock.GrantPrivilege got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGrantPrivilege.t.Errorf("ClientMock.GrantPrivilege got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGrantPrivilege.GrantPrivilegeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGrantPrivilege.GrantPrivilegeMock.defaultExpectation.results @@ -9400,7 +11609,7 @@ func (m *ClientMock) MinimockGrantPrivilegeDone() bool { func (m *ClientMock) MinimockGrantPrivilegeInspect() { for _, e := range m.GrantPrivilegeMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GrantPrivilege with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GrantPrivilege at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -9408,19 +11617,19 @@ func (m *ClientMock) MinimockGrantPrivilegeInspect() { // if default expectation was set then invocations count should be greater than zero if m.GrantPrivilegeMock.defaultExpectation != nil && afterGrantPrivilegeCounter < 1 { if m.GrantPrivilegeMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GrantPrivilege") + m.t.Errorf("Expected call to ClientMock.GrantPrivilege at\n%s", m.GrantPrivilegeMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GrantPrivilege with params: %#v", *m.GrantPrivilegeMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.GrantPrivilege at\n%s with params: %#v", m.GrantPrivilegeMock.defaultExpectation.expectationOrigins.origin, *m.GrantPrivilegeMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcGrantPrivilege != nil && afterGrantPrivilegeCounter < 1 { - m.t.Error("Expected call to ClientMock.GrantPrivilege") + m.t.Errorf("Expected call to ClientMock.GrantPrivilege at\n%s", m.funcGrantPrivilegeOrigin) } if !m.GrantPrivilegeMock.invocationsDone() && afterGrantPrivilegeCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GrantPrivilege but found %d calls", - mm_atomic.LoadUint64(&m.GrantPrivilegeMock.expectedInvocations), afterGrantPrivilegeCounter) + m.t.Errorf("Expected %d calls to ClientMock.GrantPrivilege at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GrantPrivilegeMock.expectedInvocations), m.GrantPrivilegeMock.expectedInvocationsOrigin, afterGrantPrivilegeCounter) } } @@ -9433,16 +11642,19 @@ type mClientMockGrantRole struct { callArgs []*ClientMockGrantRoleParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockGrantRoleExpectation specifies expectation struct of the Client.GrantRole type ClientMockGrantRoleExpectation struct { - mock *ClientMock - params *ClientMockGrantRoleParams - paramPtrs *ClientMockGrantRoleParamPtrs - results *ClientMockGrantRoleResults - Counter uint64 + mock *ClientMock + params *ClientMockGrantRoleParams + paramPtrs *ClientMockGrantRoleParamPtrs + expectationOrigins ClientMockGrantRoleExpectationOrigins + results *ClientMockGrantRoleResults + returnOrigin string + Counter uint64 } // ClientMockGrantRoleParams contains parameters of the Client.GrantRole @@ -9465,6 +11677,14 @@ type ClientMockGrantRoleResults struct { err error } +// ClientMockGrantRoleOrigins contains origins of expectations of the Client.GrantRole +type ClientMockGrantRoleExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originGrantRole string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -9490,6 +11710,7 @@ func (mmGrantRole *mClientMockGrantRole) Expect(ctx context.Context, serviceId s } mmGrantRole.defaultExpectation.params = &ClientMockGrantRoleParams{ctx, serviceId, grantRole} + mmGrantRole.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmGrantRole.expectations { if minimock.Equal(e.params, mmGrantRole.defaultExpectation.params) { mmGrantRole.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGrantRole.defaultExpectation.params) @@ -9517,6 +11738,7 @@ func (mmGrantRole *mClientMockGrantRole) ExpectCtxParam1(ctx context.Context) *m mmGrantRole.defaultExpectation.paramPtrs = &ClientMockGrantRoleParamPtrs{} } mmGrantRole.defaultExpectation.paramPtrs.ctx = &ctx + mmGrantRole.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmGrantRole } @@ -9539,6 +11761,7 @@ func (mmGrantRole *mClientMockGrantRole) ExpectServiceIdParam2(serviceId string) mmGrantRole.defaultExpectation.paramPtrs = &ClientMockGrantRoleParamPtrs{} } mmGrantRole.defaultExpectation.paramPtrs.serviceId = &serviceId + mmGrantRole.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmGrantRole } @@ -9561,6 +11784,7 @@ func (mmGrantRole *mClientMockGrantRole) ExpectGrantRoleParam3(grantRole GrantRo mmGrantRole.defaultExpectation.paramPtrs = &ClientMockGrantRoleParamPtrs{} } mmGrantRole.defaultExpectation.paramPtrs.grantRole = &grantRole + mmGrantRole.defaultExpectation.expectationOrigins.originGrantRole = minimock.CallerInfo(1) return mmGrantRole } @@ -9586,6 +11810,7 @@ func (mmGrantRole *mClientMockGrantRole) Return(gp1 *GrantRole, err error) *Clie mmGrantRole.defaultExpectation = &ClientMockGrantRoleExpectation{mock: mmGrantRole.mock} } mmGrantRole.defaultExpectation.results = &ClientMockGrantRoleResults{gp1, err} + mmGrantRole.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmGrantRole.mock } @@ -9600,6 +11825,7 @@ func (mmGrantRole *mClientMockGrantRole) Set(f func(ctx context.Context, service } mmGrantRole.mock.funcGrantRole = f + mmGrantRole.mock.funcGrantRoleOrigin = minimock.CallerInfo(1) return mmGrantRole.mock } @@ -9611,8 +11837,9 @@ func (mmGrantRole *mClientMockGrantRole) When(ctx context.Context, serviceId str } expectation := &ClientMockGrantRoleExpectation{ - mock: mmGrantRole.mock, - params: &ClientMockGrantRoleParams{ctx, serviceId, grantRole}, + mock: mmGrantRole.mock, + params: &ClientMockGrantRoleParams{ctx, serviceId, grantRole}, + expectationOrigins: ClientMockGrantRoleExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmGrantRole.expectations = append(mmGrantRole.expectations, expectation) return expectation @@ -9630,6 +11857,7 @@ func (mmGrantRole *mClientMockGrantRole) Times(n uint64) *mClientMockGrantRole { mmGrantRole.mock.t.Fatalf("Times of ClientMock.GrantRole mock can not be zero") } mm_atomic.StoreUint64(&mmGrantRole.expectedInvocations, n) + mmGrantRole.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmGrantRole } @@ -9649,6 +11877,8 @@ func (mmGrantRole *ClientMock) GrantRole(ctx context.Context, serviceId string, mm_atomic.AddUint64(&mmGrantRole.beforeGrantRoleCounter, 1) defer mm_atomic.AddUint64(&mmGrantRole.afterGrantRoleCounter, 1) + mmGrantRole.t.Helper() + if mmGrantRole.inspectFuncGrantRole != nil { mmGrantRole.inspectFuncGrantRole(ctx, serviceId, grantRole) } @@ -9677,19 +11907,23 @@ func (mmGrantRole *ClientMock) GrantRole(ctx context.Context, serviceId string, if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmGrantRole.t.Errorf("ClientMock.GrantRole got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmGrantRole.t.Errorf("ClientMock.GrantRole got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGrantRole.GrantRoleMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmGrantRole.t.Errorf("ClientMock.GrantRole got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmGrantRole.t.Errorf("ClientMock.GrantRole got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGrantRole.GrantRoleMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.grantRole != nil && !minimock.Equal(*mm_want_ptrs.grantRole, mm_got.grantRole) { - mmGrantRole.t.Errorf("ClientMock.GrantRole got unexpected parameter grantRole, want: %#v, got: %#v%s\n", *mm_want_ptrs.grantRole, mm_got.grantRole, minimock.Diff(*mm_want_ptrs.grantRole, mm_got.grantRole)) + mmGrantRole.t.Errorf("ClientMock.GrantRole got unexpected parameter grantRole, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGrantRole.GrantRoleMock.defaultExpectation.expectationOrigins.originGrantRole, *mm_want_ptrs.grantRole, mm_got.grantRole, minimock.Diff(*mm_want_ptrs.grantRole, mm_got.grantRole)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmGrantRole.t.Errorf("ClientMock.GrantRole got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmGrantRole.t.Errorf("ClientMock.GrantRole got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmGrantRole.GrantRoleMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmGrantRole.GrantRoleMock.defaultExpectation.results @@ -9749,27 +11983,370 @@ func (m *ClientMock) MinimockGrantRoleDone() bool { func (m *ClientMock) MinimockGrantRoleInspect() { for _, e := range m.GrantRoleMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.GrantRole with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.GrantRole at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterGrantRoleCounter := mm_atomic.LoadUint64(&m.afterGrantRoleCounter) + // if default expectation was set then invocations count should be greater than zero + if m.GrantRoleMock.defaultExpectation != nil && afterGrantRoleCounter < 1 { + if m.GrantRoleMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to ClientMock.GrantRole at\n%s", m.GrantRoleMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to ClientMock.GrantRole at\n%s with params: %#v", m.GrantRoleMock.defaultExpectation.expectationOrigins.origin, *m.GrantRoleMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcGrantRole != nil && afterGrantRoleCounter < 1 { + m.t.Errorf("Expected call to ClientMock.GrantRole at\n%s", m.funcGrantRoleOrigin) + } + + if !m.GrantRoleMock.invocationsDone() && afterGrantRoleCounter > 0 { + m.t.Errorf("Expected %d calls to ClientMock.GrantRole at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.GrantRoleMock.expectedInvocations), m.GrantRoleMock.expectedInvocationsOrigin, afterGrantRoleCounter) + } +} + +type mClientMockListReversePrivateEndpoints struct { + optional bool + mock *ClientMock + defaultExpectation *ClientMockListReversePrivateEndpointsExpectation + expectations []*ClientMockListReversePrivateEndpointsExpectation + + callArgs []*ClientMockListReversePrivateEndpointsParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// ClientMockListReversePrivateEndpointsExpectation specifies expectation struct of the Client.ListReversePrivateEndpoints +type ClientMockListReversePrivateEndpointsExpectation struct { + mock *ClientMock + params *ClientMockListReversePrivateEndpointsParams + paramPtrs *ClientMockListReversePrivateEndpointsParamPtrs + expectationOrigins ClientMockListReversePrivateEndpointsExpectationOrigins + results *ClientMockListReversePrivateEndpointsResults + returnOrigin string + Counter uint64 +} + +// ClientMockListReversePrivateEndpointsParams contains parameters of the Client.ListReversePrivateEndpoints +type ClientMockListReversePrivateEndpointsParams struct { + ctx context.Context + serviceId string +} + +// ClientMockListReversePrivateEndpointsParamPtrs contains pointers to parameters of the Client.ListReversePrivateEndpoints +type ClientMockListReversePrivateEndpointsParamPtrs struct { + ctx *context.Context + serviceId *string +} + +// ClientMockListReversePrivateEndpointsResults contains results of the Client.ListReversePrivateEndpoints +type ClientMockListReversePrivateEndpointsResults struct { + rpa1 []*ReversePrivateEndpoint + err error +} + +// ClientMockListReversePrivateEndpointsOrigins contains origins of expectations of the Client.ListReversePrivateEndpoints +type ClientMockListReversePrivateEndpointsExpectationOrigins struct { + origin string + originCtx string + originServiceId string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) Optional() *mClientMockListReversePrivateEndpoints { + mmListReversePrivateEndpoints.optional = true + return mmListReversePrivateEndpoints +} + +// Expect sets up expected params for Client.ListReversePrivateEndpoints +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) Expect(ctx context.Context, serviceId string) *mClientMockListReversePrivateEndpoints { + if mmListReversePrivateEndpoints.mock.funcListReversePrivateEndpoints != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("ClientMock.ListReversePrivateEndpoints mock is already set by Set") + } + + if mmListReversePrivateEndpoints.defaultExpectation == nil { + mmListReversePrivateEndpoints.defaultExpectation = &ClientMockListReversePrivateEndpointsExpectation{} + } + + if mmListReversePrivateEndpoints.defaultExpectation.paramPtrs != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("ClientMock.ListReversePrivateEndpoints mock is already set by ExpectParams functions") + } + + mmListReversePrivateEndpoints.defaultExpectation.params = &ClientMockListReversePrivateEndpointsParams{ctx, serviceId} + mmListReversePrivateEndpoints.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmListReversePrivateEndpoints.expectations { + if minimock.Equal(e.params, mmListReversePrivateEndpoints.defaultExpectation.params) { + mmListReversePrivateEndpoints.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmListReversePrivateEndpoints.defaultExpectation.params) + } + } + + return mmListReversePrivateEndpoints +} + +// ExpectCtxParam1 sets up expected param ctx for Client.ListReversePrivateEndpoints +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) ExpectCtxParam1(ctx context.Context) *mClientMockListReversePrivateEndpoints { + if mmListReversePrivateEndpoints.mock.funcListReversePrivateEndpoints != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("ClientMock.ListReversePrivateEndpoints mock is already set by Set") + } + + if mmListReversePrivateEndpoints.defaultExpectation == nil { + mmListReversePrivateEndpoints.defaultExpectation = &ClientMockListReversePrivateEndpointsExpectation{} + } + + if mmListReversePrivateEndpoints.defaultExpectation.params != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("ClientMock.ListReversePrivateEndpoints mock is already set by Expect") + } + + if mmListReversePrivateEndpoints.defaultExpectation.paramPtrs == nil { + mmListReversePrivateEndpoints.defaultExpectation.paramPtrs = &ClientMockListReversePrivateEndpointsParamPtrs{} + } + mmListReversePrivateEndpoints.defaultExpectation.paramPtrs.ctx = &ctx + mmListReversePrivateEndpoints.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmListReversePrivateEndpoints +} + +// ExpectServiceIdParam2 sets up expected param serviceId for Client.ListReversePrivateEndpoints +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) ExpectServiceIdParam2(serviceId string) *mClientMockListReversePrivateEndpoints { + if mmListReversePrivateEndpoints.mock.funcListReversePrivateEndpoints != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("ClientMock.ListReversePrivateEndpoints mock is already set by Set") + } + + if mmListReversePrivateEndpoints.defaultExpectation == nil { + mmListReversePrivateEndpoints.defaultExpectation = &ClientMockListReversePrivateEndpointsExpectation{} + } + + if mmListReversePrivateEndpoints.defaultExpectation.params != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("ClientMock.ListReversePrivateEndpoints mock is already set by Expect") + } + + if mmListReversePrivateEndpoints.defaultExpectation.paramPtrs == nil { + mmListReversePrivateEndpoints.defaultExpectation.paramPtrs = &ClientMockListReversePrivateEndpointsParamPtrs{} + } + mmListReversePrivateEndpoints.defaultExpectation.paramPtrs.serviceId = &serviceId + mmListReversePrivateEndpoints.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) + + return mmListReversePrivateEndpoints +} + +// Inspect accepts an inspector function that has same arguments as the Client.ListReversePrivateEndpoints +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) Inspect(f func(ctx context.Context, serviceId string)) *mClientMockListReversePrivateEndpoints { + if mmListReversePrivateEndpoints.mock.inspectFuncListReversePrivateEndpoints != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("Inspect function is already set for ClientMock.ListReversePrivateEndpoints") + } + + mmListReversePrivateEndpoints.mock.inspectFuncListReversePrivateEndpoints = f + + return mmListReversePrivateEndpoints +} + +// Return sets up results that will be returned by Client.ListReversePrivateEndpoints +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) Return(rpa1 []*ReversePrivateEndpoint, err error) *ClientMock { + if mmListReversePrivateEndpoints.mock.funcListReversePrivateEndpoints != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("ClientMock.ListReversePrivateEndpoints mock is already set by Set") + } + + if mmListReversePrivateEndpoints.defaultExpectation == nil { + mmListReversePrivateEndpoints.defaultExpectation = &ClientMockListReversePrivateEndpointsExpectation{mock: mmListReversePrivateEndpoints.mock} + } + mmListReversePrivateEndpoints.defaultExpectation.results = &ClientMockListReversePrivateEndpointsResults{rpa1, err} + mmListReversePrivateEndpoints.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmListReversePrivateEndpoints.mock +} + +// Set uses given function f to mock the Client.ListReversePrivateEndpoints method +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) Set(f func(ctx context.Context, serviceId string) (rpa1 []*ReversePrivateEndpoint, err error)) *ClientMock { + if mmListReversePrivateEndpoints.defaultExpectation != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("Default expectation is already set for the Client.ListReversePrivateEndpoints method") + } + + if len(mmListReversePrivateEndpoints.expectations) > 0 { + mmListReversePrivateEndpoints.mock.t.Fatalf("Some expectations are already set for the Client.ListReversePrivateEndpoints method") + } + + mmListReversePrivateEndpoints.mock.funcListReversePrivateEndpoints = f + mmListReversePrivateEndpoints.mock.funcListReversePrivateEndpointsOrigin = minimock.CallerInfo(1) + return mmListReversePrivateEndpoints.mock +} + +// When sets expectation for the Client.ListReversePrivateEndpoints which will trigger the result defined by the following +// Then helper +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) When(ctx context.Context, serviceId string) *ClientMockListReversePrivateEndpointsExpectation { + if mmListReversePrivateEndpoints.mock.funcListReversePrivateEndpoints != nil { + mmListReversePrivateEndpoints.mock.t.Fatalf("ClientMock.ListReversePrivateEndpoints mock is already set by Set") + } + + expectation := &ClientMockListReversePrivateEndpointsExpectation{ + mock: mmListReversePrivateEndpoints.mock, + params: &ClientMockListReversePrivateEndpointsParams{ctx, serviceId}, + expectationOrigins: ClientMockListReversePrivateEndpointsExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmListReversePrivateEndpoints.expectations = append(mmListReversePrivateEndpoints.expectations, expectation) + return expectation +} + +// Then sets up Client.ListReversePrivateEndpoints return parameters for the expectation previously defined by the When method +func (e *ClientMockListReversePrivateEndpointsExpectation) Then(rpa1 []*ReversePrivateEndpoint, err error) *ClientMock { + e.results = &ClientMockListReversePrivateEndpointsResults{rpa1, err} + return e.mock +} + +// Times sets number of times Client.ListReversePrivateEndpoints should be invoked +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) Times(n uint64) *mClientMockListReversePrivateEndpoints { + if n == 0 { + mmListReversePrivateEndpoints.mock.t.Fatalf("Times of ClientMock.ListReversePrivateEndpoints mock can not be zero") + } + mm_atomic.StoreUint64(&mmListReversePrivateEndpoints.expectedInvocations, n) + mmListReversePrivateEndpoints.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmListReversePrivateEndpoints +} + +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) invocationsDone() bool { + if len(mmListReversePrivateEndpoints.expectations) == 0 && mmListReversePrivateEndpoints.defaultExpectation == nil && mmListReversePrivateEndpoints.mock.funcListReversePrivateEndpoints == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmListReversePrivateEndpoints.mock.afterListReversePrivateEndpointsCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmListReversePrivateEndpoints.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// ListReversePrivateEndpoints implements Client +func (mmListReversePrivateEndpoints *ClientMock) ListReversePrivateEndpoints(ctx context.Context, serviceId string) (rpa1 []*ReversePrivateEndpoint, err error) { + mm_atomic.AddUint64(&mmListReversePrivateEndpoints.beforeListReversePrivateEndpointsCounter, 1) + defer mm_atomic.AddUint64(&mmListReversePrivateEndpoints.afterListReversePrivateEndpointsCounter, 1) + + mmListReversePrivateEndpoints.t.Helper() + + if mmListReversePrivateEndpoints.inspectFuncListReversePrivateEndpoints != nil { + mmListReversePrivateEndpoints.inspectFuncListReversePrivateEndpoints(ctx, serviceId) + } + + mm_params := ClientMockListReversePrivateEndpointsParams{ctx, serviceId} + + // Record call args + mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.mutex.Lock() + mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.callArgs = append(mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.callArgs, &mm_params) + mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.mutex.Unlock() + + for _, e := range mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.rpa1, e.results.err + } + } + + if mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.defaultExpectation.Counter, 1) + mm_want := mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.defaultExpectation.params + mm_want_ptrs := mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.defaultExpectation.paramPtrs + + mm_got := ClientMockListReversePrivateEndpointsParams{ctx, serviceId} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmListReversePrivateEndpoints.t.Errorf("ClientMock.ListReversePrivateEndpoints got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { + mmListReversePrivateEndpoints.t.Errorf("ClientMock.ListReversePrivateEndpoints got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmListReversePrivateEndpoints.t.Errorf("ClientMock.ListReversePrivateEndpoints got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmListReversePrivateEndpoints.ListReversePrivateEndpointsMock.defaultExpectation.results + if mm_results == nil { + mmListReversePrivateEndpoints.t.Fatal("No results are set for the ClientMock.ListReversePrivateEndpoints") + } + return (*mm_results).rpa1, (*mm_results).err + } + if mmListReversePrivateEndpoints.funcListReversePrivateEndpoints != nil { + return mmListReversePrivateEndpoints.funcListReversePrivateEndpoints(ctx, serviceId) + } + mmListReversePrivateEndpoints.t.Fatalf("Unexpected call to ClientMock.ListReversePrivateEndpoints. %v %v", ctx, serviceId) + return +} + +// ListReversePrivateEndpointsAfterCounter returns a count of finished ClientMock.ListReversePrivateEndpoints invocations +func (mmListReversePrivateEndpoints *ClientMock) ListReversePrivateEndpointsAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmListReversePrivateEndpoints.afterListReversePrivateEndpointsCounter) +} + +// ListReversePrivateEndpointsBeforeCounter returns a count of ClientMock.ListReversePrivateEndpoints invocations +func (mmListReversePrivateEndpoints *ClientMock) ListReversePrivateEndpointsBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmListReversePrivateEndpoints.beforeListReversePrivateEndpointsCounter) +} + +// Calls returns a list of arguments used in each call to ClientMock.ListReversePrivateEndpoints. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmListReversePrivateEndpoints *mClientMockListReversePrivateEndpoints) Calls() []*ClientMockListReversePrivateEndpointsParams { + mmListReversePrivateEndpoints.mutex.RLock() + + argCopy := make([]*ClientMockListReversePrivateEndpointsParams, len(mmListReversePrivateEndpoints.callArgs)) + copy(argCopy, mmListReversePrivateEndpoints.callArgs) + + mmListReversePrivateEndpoints.mutex.RUnlock() + + return argCopy +} + +// MinimockListReversePrivateEndpointsDone returns true if the count of the ListReversePrivateEndpoints invocations corresponds +// the number of defined expectations +func (m *ClientMock) MinimockListReversePrivateEndpointsDone() bool { + if m.ListReversePrivateEndpointsMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.ListReversePrivateEndpointsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.ListReversePrivateEndpointsMock.invocationsDone() +} + +// MinimockListReversePrivateEndpointsInspect logs each unmet expectation +func (m *ClientMock) MinimockListReversePrivateEndpointsInspect() { + for _, e := range m.ListReversePrivateEndpointsMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to ClientMock.ListReversePrivateEndpoints at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } - afterGrantRoleCounter := mm_atomic.LoadUint64(&m.afterGrantRoleCounter) + afterListReversePrivateEndpointsCounter := mm_atomic.LoadUint64(&m.afterListReversePrivateEndpointsCounter) // if default expectation was set then invocations count should be greater than zero - if m.GrantRoleMock.defaultExpectation != nil && afterGrantRoleCounter < 1 { - if m.GrantRoleMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.GrantRole") + if m.ListReversePrivateEndpointsMock.defaultExpectation != nil && afterListReversePrivateEndpointsCounter < 1 { + if m.ListReversePrivateEndpointsMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to ClientMock.ListReversePrivateEndpoints at\n%s", m.ListReversePrivateEndpointsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.GrantRole with params: %#v", *m.GrantRoleMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.ListReversePrivateEndpoints at\n%s with params: %#v", m.ListReversePrivateEndpointsMock.defaultExpectation.expectationOrigins.origin, *m.ListReversePrivateEndpointsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero - if m.funcGrantRole != nil && afterGrantRoleCounter < 1 { - m.t.Error("Expected call to ClientMock.GrantRole") + if m.funcListReversePrivateEndpoints != nil && afterListReversePrivateEndpointsCounter < 1 { + m.t.Errorf("Expected call to ClientMock.ListReversePrivateEndpoints at\n%s", m.funcListReversePrivateEndpointsOrigin) } - if !m.GrantRoleMock.invocationsDone() && afterGrantRoleCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.GrantRole but found %d calls", - mm_atomic.LoadUint64(&m.GrantRoleMock.expectedInvocations), afterGrantRoleCounter) + if !m.ListReversePrivateEndpointsMock.invocationsDone() && afterListReversePrivateEndpointsCounter > 0 { + m.t.Errorf("Expected %d calls to ClientMock.ListReversePrivateEndpoints at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ListReversePrivateEndpointsMock.expectedInvocations), m.ListReversePrivateEndpointsMock.expectedInvocationsOrigin, afterListReversePrivateEndpointsCounter) } } @@ -9782,16 +12359,19 @@ type mClientMockRevokeGrantPrivilege struct { callArgs []*ClientMockRevokeGrantPrivilegeParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockRevokeGrantPrivilegeExpectation specifies expectation struct of the Client.RevokeGrantPrivilege type ClientMockRevokeGrantPrivilegeExpectation struct { - mock *ClientMock - params *ClientMockRevokeGrantPrivilegeParams - paramPtrs *ClientMockRevokeGrantPrivilegeParamPtrs - results *ClientMockRevokeGrantPrivilegeResults - Counter uint64 + mock *ClientMock + params *ClientMockRevokeGrantPrivilegeParams + paramPtrs *ClientMockRevokeGrantPrivilegeParamPtrs + expectationOrigins ClientMockRevokeGrantPrivilegeExpectationOrigins + results *ClientMockRevokeGrantPrivilegeResults + returnOrigin string + Counter uint64 } // ClientMockRevokeGrantPrivilegeParams contains parameters of the Client.RevokeGrantPrivilege @@ -9823,6 +12403,19 @@ type ClientMockRevokeGrantPrivilegeResults struct { err error } +// ClientMockRevokeGrantPrivilegeOrigins contains origins of expectations of the Client.RevokeGrantPrivilege +type ClientMockRevokeGrantPrivilegeExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originAccessType string + originDatabase string + originTable string + originColumn string + originGranteeUserName string + originGranteeRoleName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -9848,6 +12441,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) Expect(ctx contex } mmRevokeGrantPrivilege.defaultExpectation.params = &ClientMockRevokeGrantPrivilegeParams{ctx, serviceID, accessType, database, table, column, granteeUserName, granteeRoleName} + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmRevokeGrantPrivilege.expectations { if minimock.Equal(e.params, mmRevokeGrantPrivilege.defaultExpectation.params) { mmRevokeGrantPrivilege.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmRevokeGrantPrivilege.defaultExpectation.params) @@ -9875,6 +12469,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) ExpectCtxParam1(c mmRevokeGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockRevokeGrantPrivilegeParamPtrs{} } mmRevokeGrantPrivilege.defaultExpectation.paramPtrs.ctx = &ctx + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -9897,6 +12492,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) ExpectServiceIDPa mmRevokeGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockRevokeGrantPrivilegeParamPtrs{} } mmRevokeGrantPrivilege.defaultExpectation.paramPtrs.serviceID = &serviceID + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -9919,6 +12515,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) ExpectAccessTypeP mmRevokeGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockRevokeGrantPrivilegeParamPtrs{} } mmRevokeGrantPrivilege.defaultExpectation.paramPtrs.accessType = &accessType + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.originAccessType = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -9941,6 +12538,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) ExpectDatabasePar mmRevokeGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockRevokeGrantPrivilegeParamPtrs{} } mmRevokeGrantPrivilege.defaultExpectation.paramPtrs.database = &database + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.originDatabase = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -9963,6 +12561,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) ExpectTableParam5 mmRevokeGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockRevokeGrantPrivilegeParamPtrs{} } mmRevokeGrantPrivilege.defaultExpectation.paramPtrs.table = &table + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.originTable = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -9985,6 +12584,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) ExpectColumnParam mmRevokeGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockRevokeGrantPrivilegeParamPtrs{} } mmRevokeGrantPrivilege.defaultExpectation.paramPtrs.column = &column + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.originColumn = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -10007,6 +12607,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) ExpectGranteeUser mmRevokeGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockRevokeGrantPrivilegeParamPtrs{} } mmRevokeGrantPrivilege.defaultExpectation.paramPtrs.granteeUserName = &granteeUserName + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.originGranteeUserName = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -10029,6 +12630,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) ExpectGranteeRole mmRevokeGrantPrivilege.defaultExpectation.paramPtrs = &ClientMockRevokeGrantPrivilegeParamPtrs{} } mmRevokeGrantPrivilege.defaultExpectation.paramPtrs.granteeRoleName = &granteeRoleName + mmRevokeGrantPrivilege.defaultExpectation.expectationOrigins.originGranteeRoleName = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -10054,6 +12656,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) Return(err error) mmRevokeGrantPrivilege.defaultExpectation = &ClientMockRevokeGrantPrivilegeExpectation{mock: mmRevokeGrantPrivilege.mock} } mmRevokeGrantPrivilege.defaultExpectation.results = &ClientMockRevokeGrantPrivilegeResults{err} + mmRevokeGrantPrivilege.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmRevokeGrantPrivilege.mock } @@ -10068,6 +12671,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) Set(f func(ctx co } mmRevokeGrantPrivilege.mock.funcRevokeGrantPrivilege = f + mmRevokeGrantPrivilege.mock.funcRevokeGrantPrivilegeOrigin = minimock.CallerInfo(1) return mmRevokeGrantPrivilege.mock } @@ -10079,8 +12683,9 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) When(ctx context. } expectation := &ClientMockRevokeGrantPrivilegeExpectation{ - mock: mmRevokeGrantPrivilege.mock, - params: &ClientMockRevokeGrantPrivilegeParams{ctx, serviceID, accessType, database, table, column, granteeUserName, granteeRoleName}, + mock: mmRevokeGrantPrivilege.mock, + params: &ClientMockRevokeGrantPrivilegeParams{ctx, serviceID, accessType, database, table, column, granteeUserName, granteeRoleName}, + expectationOrigins: ClientMockRevokeGrantPrivilegeExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmRevokeGrantPrivilege.expectations = append(mmRevokeGrantPrivilege.expectations, expectation) return expectation @@ -10098,6 +12703,7 @@ func (mmRevokeGrantPrivilege *mClientMockRevokeGrantPrivilege) Times(n uint64) * mmRevokeGrantPrivilege.mock.t.Fatalf("Times of ClientMock.RevokeGrantPrivilege mock can not be zero") } mm_atomic.StoreUint64(&mmRevokeGrantPrivilege.expectedInvocations, n) + mmRevokeGrantPrivilege.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmRevokeGrantPrivilege } @@ -10117,6 +12723,8 @@ func (mmRevokeGrantPrivilege *ClientMock) RevokeGrantPrivilege(ctx context.Conte mm_atomic.AddUint64(&mmRevokeGrantPrivilege.beforeRevokeGrantPrivilegeCounter, 1) defer mm_atomic.AddUint64(&mmRevokeGrantPrivilege.afterRevokeGrantPrivilegeCounter, 1) + mmRevokeGrantPrivilege.t.Helper() + if mmRevokeGrantPrivilege.inspectFuncRevokeGrantPrivilege != nil { mmRevokeGrantPrivilege.inspectFuncRevokeGrantPrivilege(ctx, serviceID, accessType, database, table, column, granteeUserName, granteeRoleName) } @@ -10145,39 +12753,48 @@ func (mmRevokeGrantPrivilege *ClientMock) RevokeGrantPrivilege(ctx context.Conte if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.accessType != nil && !minimock.Equal(*mm_want_ptrs.accessType, mm_got.accessType) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter accessType, want: %#v, got: %#v%s\n", *mm_want_ptrs.accessType, mm_got.accessType, minimock.Diff(*mm_want_ptrs.accessType, mm_got.accessType)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter accessType, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.originAccessType, *mm_want_ptrs.accessType, mm_got.accessType, minimock.Diff(*mm_want_ptrs.accessType, mm_got.accessType)) } if mm_want_ptrs.database != nil && !minimock.Equal(*mm_want_ptrs.database, mm_got.database) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter database, want: %#v, got: %#v%s\n", *mm_want_ptrs.database, mm_got.database, minimock.Diff(*mm_want_ptrs.database, mm_got.database)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter database, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.originDatabase, *mm_want_ptrs.database, mm_got.database, minimock.Diff(*mm_want_ptrs.database, mm_got.database)) } if mm_want_ptrs.table != nil && !minimock.Equal(*mm_want_ptrs.table, mm_got.table) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter table, want: %#v, got: %#v%s\n", *mm_want_ptrs.table, mm_got.table, minimock.Diff(*mm_want_ptrs.table, mm_got.table)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter table, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.originTable, *mm_want_ptrs.table, mm_got.table, minimock.Diff(*mm_want_ptrs.table, mm_got.table)) } if mm_want_ptrs.column != nil && !minimock.Equal(*mm_want_ptrs.column, mm_got.column) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter column, want: %#v, got: %#v%s\n", *mm_want_ptrs.column, mm_got.column, minimock.Diff(*mm_want_ptrs.column, mm_got.column)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter column, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.originColumn, *mm_want_ptrs.column, mm_got.column, minimock.Diff(*mm_want_ptrs.column, mm_got.column)) } if mm_want_ptrs.granteeUserName != nil && !minimock.Equal(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter granteeUserName, want: %#v, got: %#v%s\n", *mm_want_ptrs.granteeUserName, mm_got.granteeUserName, minimock.Diff(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter granteeUserName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.originGranteeUserName, *mm_want_ptrs.granteeUserName, mm_got.granteeUserName, minimock.Diff(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName)) } if mm_want_ptrs.granteeRoleName != nil && !minimock.Equal(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter granteeRoleName, want: %#v, got: %#v%s\n", *mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName, minimock.Diff(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameter granteeRoleName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.originGranteeRoleName, *mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName, minimock.Diff(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmRevokeGrantPrivilege.t.Errorf("ClientMock.RevokeGrantPrivilege got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmRevokeGrantPrivilege.RevokeGrantPrivilegeMock.defaultExpectation.results @@ -10237,7 +12854,7 @@ func (m *ClientMock) MinimockRevokeGrantPrivilegeDone() bool { func (m *ClientMock) MinimockRevokeGrantPrivilegeInspect() { for _, e := range m.RevokeGrantPrivilegeMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.RevokeGrantPrivilege with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.RevokeGrantPrivilege at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -10245,19 +12862,19 @@ func (m *ClientMock) MinimockRevokeGrantPrivilegeInspect() { // if default expectation was set then invocations count should be greater than zero if m.RevokeGrantPrivilegeMock.defaultExpectation != nil && afterRevokeGrantPrivilegeCounter < 1 { if m.RevokeGrantPrivilegeMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.RevokeGrantPrivilege") + m.t.Errorf("Expected call to ClientMock.RevokeGrantPrivilege at\n%s", m.RevokeGrantPrivilegeMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.RevokeGrantPrivilege with params: %#v", *m.RevokeGrantPrivilegeMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.RevokeGrantPrivilege at\n%s with params: %#v", m.RevokeGrantPrivilegeMock.defaultExpectation.expectationOrigins.origin, *m.RevokeGrantPrivilegeMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcRevokeGrantPrivilege != nil && afterRevokeGrantPrivilegeCounter < 1 { - m.t.Error("Expected call to ClientMock.RevokeGrantPrivilege") + m.t.Errorf("Expected call to ClientMock.RevokeGrantPrivilege at\n%s", m.funcRevokeGrantPrivilegeOrigin) } if !m.RevokeGrantPrivilegeMock.invocationsDone() && afterRevokeGrantPrivilegeCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.RevokeGrantPrivilege but found %d calls", - mm_atomic.LoadUint64(&m.RevokeGrantPrivilegeMock.expectedInvocations), afterRevokeGrantPrivilegeCounter) + m.t.Errorf("Expected %d calls to ClientMock.RevokeGrantPrivilege at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.RevokeGrantPrivilegeMock.expectedInvocations), m.RevokeGrantPrivilegeMock.expectedInvocationsOrigin, afterRevokeGrantPrivilegeCounter) } } @@ -10270,16 +12887,19 @@ type mClientMockRevokeGrantRole struct { callArgs []*ClientMockRevokeGrantRoleParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockRevokeGrantRoleExpectation specifies expectation struct of the Client.RevokeGrantRole type ClientMockRevokeGrantRoleExpectation struct { - mock *ClientMock - params *ClientMockRevokeGrantRoleParams - paramPtrs *ClientMockRevokeGrantRoleParamPtrs - results *ClientMockRevokeGrantRoleResults - Counter uint64 + mock *ClientMock + params *ClientMockRevokeGrantRoleParams + paramPtrs *ClientMockRevokeGrantRoleParamPtrs + expectationOrigins ClientMockRevokeGrantRoleExpectationOrigins + results *ClientMockRevokeGrantRoleResults + returnOrigin string + Counter uint64 } // ClientMockRevokeGrantRoleParams contains parameters of the Client.RevokeGrantRole @@ -10305,6 +12925,16 @@ type ClientMockRevokeGrantRoleResults struct { err error } +// ClientMockRevokeGrantRoleOrigins contains origins of expectations of the Client.RevokeGrantRole +type ClientMockRevokeGrantRoleExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originGrantedRoleName string + originGranteeUserName string + originGranteeRoleName string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -10330,6 +12960,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) Expect(ctx context.Context, } mmRevokeGrantRole.defaultExpectation.params = &ClientMockRevokeGrantRoleParams{ctx, serviceID, grantedRoleName, granteeUserName, granteeRoleName} + mmRevokeGrantRole.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmRevokeGrantRole.expectations { if minimock.Equal(e.params, mmRevokeGrantRole.defaultExpectation.params) { mmRevokeGrantRole.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmRevokeGrantRole.defaultExpectation.params) @@ -10357,6 +12988,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) ExpectCtxParam1(ctx context mmRevokeGrantRole.defaultExpectation.paramPtrs = &ClientMockRevokeGrantRoleParamPtrs{} } mmRevokeGrantRole.defaultExpectation.paramPtrs.ctx = &ctx + mmRevokeGrantRole.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmRevokeGrantRole } @@ -10379,6 +13011,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) ExpectServiceIDParam2(servi mmRevokeGrantRole.defaultExpectation.paramPtrs = &ClientMockRevokeGrantRoleParamPtrs{} } mmRevokeGrantRole.defaultExpectation.paramPtrs.serviceID = &serviceID + mmRevokeGrantRole.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmRevokeGrantRole } @@ -10401,6 +13034,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) ExpectGrantedRoleNameParam3 mmRevokeGrantRole.defaultExpectation.paramPtrs = &ClientMockRevokeGrantRoleParamPtrs{} } mmRevokeGrantRole.defaultExpectation.paramPtrs.grantedRoleName = &grantedRoleName + mmRevokeGrantRole.defaultExpectation.expectationOrigins.originGrantedRoleName = minimock.CallerInfo(1) return mmRevokeGrantRole } @@ -10423,6 +13057,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) ExpectGranteeUserNameParam4 mmRevokeGrantRole.defaultExpectation.paramPtrs = &ClientMockRevokeGrantRoleParamPtrs{} } mmRevokeGrantRole.defaultExpectation.paramPtrs.granteeUserName = &granteeUserName + mmRevokeGrantRole.defaultExpectation.expectationOrigins.originGranteeUserName = minimock.CallerInfo(1) return mmRevokeGrantRole } @@ -10445,6 +13080,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) ExpectGranteeRoleNameParam5 mmRevokeGrantRole.defaultExpectation.paramPtrs = &ClientMockRevokeGrantRoleParamPtrs{} } mmRevokeGrantRole.defaultExpectation.paramPtrs.granteeRoleName = &granteeRoleName + mmRevokeGrantRole.defaultExpectation.expectationOrigins.originGranteeRoleName = minimock.CallerInfo(1) return mmRevokeGrantRole } @@ -10470,6 +13106,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) Return(err error) *ClientMo mmRevokeGrantRole.defaultExpectation = &ClientMockRevokeGrantRoleExpectation{mock: mmRevokeGrantRole.mock} } mmRevokeGrantRole.defaultExpectation.results = &ClientMockRevokeGrantRoleResults{err} + mmRevokeGrantRole.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmRevokeGrantRole.mock } @@ -10484,6 +13121,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) Set(f func(ctx context.Cont } mmRevokeGrantRole.mock.funcRevokeGrantRole = f + mmRevokeGrantRole.mock.funcRevokeGrantRoleOrigin = minimock.CallerInfo(1) return mmRevokeGrantRole.mock } @@ -10495,8 +13133,9 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) When(ctx context.Context, s } expectation := &ClientMockRevokeGrantRoleExpectation{ - mock: mmRevokeGrantRole.mock, - params: &ClientMockRevokeGrantRoleParams{ctx, serviceID, grantedRoleName, granteeUserName, granteeRoleName}, + mock: mmRevokeGrantRole.mock, + params: &ClientMockRevokeGrantRoleParams{ctx, serviceID, grantedRoleName, granteeUserName, granteeRoleName}, + expectationOrigins: ClientMockRevokeGrantRoleExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmRevokeGrantRole.expectations = append(mmRevokeGrantRole.expectations, expectation) return expectation @@ -10514,6 +13153,7 @@ func (mmRevokeGrantRole *mClientMockRevokeGrantRole) Times(n uint64) *mClientMoc mmRevokeGrantRole.mock.t.Fatalf("Times of ClientMock.RevokeGrantRole mock can not be zero") } mm_atomic.StoreUint64(&mmRevokeGrantRole.expectedInvocations, n) + mmRevokeGrantRole.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmRevokeGrantRole } @@ -10533,6 +13173,8 @@ func (mmRevokeGrantRole *ClientMock) RevokeGrantRole(ctx context.Context, servic mm_atomic.AddUint64(&mmRevokeGrantRole.beforeRevokeGrantRoleCounter, 1) defer mm_atomic.AddUint64(&mmRevokeGrantRole.afterRevokeGrantRoleCounter, 1) + mmRevokeGrantRole.t.Helper() + if mmRevokeGrantRole.inspectFuncRevokeGrantRole != nil { mmRevokeGrantRole.inspectFuncRevokeGrantRole(ctx, serviceID, grantedRoleName, granteeUserName, granteeRoleName) } @@ -10561,27 +13203,33 @@ func (mmRevokeGrantRole *ClientMock) RevokeGrantRole(ctx context.Context, servic if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantRole.RevokeGrantRoleMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantRole.RevokeGrantRoleMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.grantedRoleName != nil && !minimock.Equal(*mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName) { - mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter grantedRoleName, want: %#v, got: %#v%s\n", *mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName, minimock.Diff(*mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName)) + mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter grantedRoleName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantRole.RevokeGrantRoleMock.defaultExpectation.expectationOrigins.originGrantedRoleName, *mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName, minimock.Diff(*mm_want_ptrs.grantedRoleName, mm_got.grantedRoleName)) } if mm_want_ptrs.granteeUserName != nil && !minimock.Equal(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName) { - mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter granteeUserName, want: %#v, got: %#v%s\n", *mm_want_ptrs.granteeUserName, mm_got.granteeUserName, minimock.Diff(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName)) + mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter granteeUserName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantRole.RevokeGrantRoleMock.defaultExpectation.expectationOrigins.originGranteeUserName, *mm_want_ptrs.granteeUserName, mm_got.granteeUserName, minimock.Diff(*mm_want_ptrs.granteeUserName, mm_got.granteeUserName)) } if mm_want_ptrs.granteeRoleName != nil && !minimock.Equal(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName) { - mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter granteeRoleName, want: %#v, got: %#v%s\n", *mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName, minimock.Diff(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName)) + mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameter granteeRoleName, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantRole.RevokeGrantRoleMock.defaultExpectation.expectationOrigins.originGranteeRoleName, *mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName, minimock.Diff(*mm_want_ptrs.granteeRoleName, mm_got.granteeRoleName)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmRevokeGrantRole.t.Errorf("ClientMock.RevokeGrantRole got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmRevokeGrantRole.RevokeGrantRoleMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmRevokeGrantRole.RevokeGrantRoleMock.defaultExpectation.results @@ -10641,7 +13289,7 @@ func (m *ClientMock) MinimockRevokeGrantRoleDone() bool { func (m *ClientMock) MinimockRevokeGrantRoleInspect() { for _, e := range m.RevokeGrantRoleMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.RevokeGrantRole with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.RevokeGrantRole at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -10649,19 +13297,19 @@ func (m *ClientMock) MinimockRevokeGrantRoleInspect() { // if default expectation was set then invocations count should be greater than zero if m.RevokeGrantRoleMock.defaultExpectation != nil && afterRevokeGrantRoleCounter < 1 { if m.RevokeGrantRoleMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.RevokeGrantRole") + m.t.Errorf("Expected call to ClientMock.RevokeGrantRole at\n%s", m.RevokeGrantRoleMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.RevokeGrantRole with params: %#v", *m.RevokeGrantRoleMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.RevokeGrantRole at\n%s with params: %#v", m.RevokeGrantRoleMock.defaultExpectation.expectationOrigins.origin, *m.RevokeGrantRoleMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcRevokeGrantRole != nil && afterRevokeGrantRoleCounter < 1 { - m.t.Error("Expected call to ClientMock.RevokeGrantRole") + m.t.Errorf("Expected call to ClientMock.RevokeGrantRole at\n%s", m.funcRevokeGrantRoleOrigin) } if !m.RevokeGrantRoleMock.invocationsDone() && afterRevokeGrantRoleCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.RevokeGrantRole but found %d calls", - mm_atomic.LoadUint64(&m.RevokeGrantRoleMock.expectedInvocations), afterRevokeGrantRoleCounter) + m.t.Errorf("Expected %d calls to ClientMock.RevokeGrantRole at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.RevokeGrantRoleMock.expectedInvocations), m.RevokeGrantRoleMock.expectedInvocationsOrigin, afterRevokeGrantRoleCounter) } } @@ -10674,16 +13322,19 @@ type mClientMockScalingClickPipe struct { callArgs []*ClientMockScalingClickPipeParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockScalingClickPipeExpectation specifies expectation struct of the Client.ScalingClickPipe type ClientMockScalingClickPipeExpectation struct { - mock *ClientMock - params *ClientMockScalingClickPipeParams - paramPtrs *ClientMockScalingClickPipeParamPtrs - results *ClientMockScalingClickPipeResults - Counter uint64 + mock *ClientMock + params *ClientMockScalingClickPipeParams + paramPtrs *ClientMockScalingClickPipeParamPtrs + expectationOrigins ClientMockScalingClickPipeExpectationOrigins + results *ClientMockScalingClickPipeResults + returnOrigin string + Counter uint64 } // ClientMockScalingClickPipeParams contains parameters of the Client.ScalingClickPipe @@ -10708,6 +13359,15 @@ type ClientMockScalingClickPipeResults struct { err error } +// ClientMockScalingClickPipeOrigins contains origins of expectations of the Client.ScalingClickPipe +type ClientMockScalingClickPipeExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originClickPipeId string + originRequest string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -10733,6 +13393,7 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) Expect(ctx context.Contex } mmScalingClickPipe.defaultExpectation.params = &ClientMockScalingClickPipeParams{ctx, serviceId, clickPipeId, request} + mmScalingClickPipe.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmScalingClickPipe.expectations { if minimock.Equal(e.params, mmScalingClickPipe.defaultExpectation.params) { mmScalingClickPipe.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmScalingClickPipe.defaultExpectation.params) @@ -10760,6 +13421,7 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) ExpectCtxParam1(ctx conte mmScalingClickPipe.defaultExpectation.paramPtrs = &ClientMockScalingClickPipeParamPtrs{} } mmScalingClickPipe.defaultExpectation.paramPtrs.ctx = &ctx + mmScalingClickPipe.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmScalingClickPipe } @@ -10782,6 +13444,7 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) ExpectServiceIdParam2(ser mmScalingClickPipe.defaultExpectation.paramPtrs = &ClientMockScalingClickPipeParamPtrs{} } mmScalingClickPipe.defaultExpectation.paramPtrs.serviceId = &serviceId + mmScalingClickPipe.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmScalingClickPipe } @@ -10804,6 +13467,7 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) ExpectClickPipeIdParam3(c mmScalingClickPipe.defaultExpectation.paramPtrs = &ClientMockScalingClickPipeParamPtrs{} } mmScalingClickPipe.defaultExpectation.paramPtrs.clickPipeId = &clickPipeId + mmScalingClickPipe.defaultExpectation.expectationOrigins.originClickPipeId = minimock.CallerInfo(1) return mmScalingClickPipe } @@ -10826,6 +13490,7 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) ExpectRequestParam4(reque mmScalingClickPipe.defaultExpectation.paramPtrs = &ClientMockScalingClickPipeParamPtrs{} } mmScalingClickPipe.defaultExpectation.paramPtrs.request = &request + mmScalingClickPipe.defaultExpectation.expectationOrigins.originRequest = minimock.CallerInfo(1) return mmScalingClickPipe } @@ -10851,6 +13516,7 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) Return(cp1 *ClickPipe, er mmScalingClickPipe.defaultExpectation = &ClientMockScalingClickPipeExpectation{mock: mmScalingClickPipe.mock} } mmScalingClickPipe.defaultExpectation.results = &ClientMockScalingClickPipeResults{cp1, err} + mmScalingClickPipe.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmScalingClickPipe.mock } @@ -10865,6 +13531,7 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) Set(f func(ctx context.Co } mmScalingClickPipe.mock.funcScalingClickPipe = f + mmScalingClickPipe.mock.funcScalingClickPipeOrigin = minimock.CallerInfo(1) return mmScalingClickPipe.mock } @@ -10876,8 +13543,9 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) When(ctx context.Context, } expectation := &ClientMockScalingClickPipeExpectation{ - mock: mmScalingClickPipe.mock, - params: &ClientMockScalingClickPipeParams{ctx, serviceId, clickPipeId, request}, + mock: mmScalingClickPipe.mock, + params: &ClientMockScalingClickPipeParams{ctx, serviceId, clickPipeId, request}, + expectationOrigins: ClientMockScalingClickPipeExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmScalingClickPipe.expectations = append(mmScalingClickPipe.expectations, expectation) return expectation @@ -10895,6 +13563,7 @@ func (mmScalingClickPipe *mClientMockScalingClickPipe) Times(n uint64) *mClientM mmScalingClickPipe.mock.t.Fatalf("Times of ClientMock.ScalingClickPipe mock can not be zero") } mm_atomic.StoreUint64(&mmScalingClickPipe.expectedInvocations, n) + mmScalingClickPipe.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmScalingClickPipe } @@ -10914,6 +13583,8 @@ func (mmScalingClickPipe *ClientMock) ScalingClickPipe(ctx context.Context, serv mm_atomic.AddUint64(&mmScalingClickPipe.beforeScalingClickPipeCounter, 1) defer mm_atomic.AddUint64(&mmScalingClickPipe.afterScalingClickPipeCounter, 1) + mmScalingClickPipe.t.Helper() + if mmScalingClickPipe.inspectFuncScalingClickPipe != nil { mmScalingClickPipe.inspectFuncScalingClickPipe(ctx, serviceId, clickPipeId, request) } @@ -10942,23 +13613,28 @@ func (mmScalingClickPipe *ClientMock) ScalingClickPipe(ctx context.Context, serv if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmScalingClickPipe.ScalingClickPipeMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmScalingClickPipe.ScalingClickPipeMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.clickPipeId != nil && !minimock.Equal(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId) { - mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameter clickPipeId, want: %#v, got: %#v%s\n", *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) + mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameter clickPipeId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmScalingClickPipe.ScalingClickPipeMock.defaultExpectation.expectationOrigins.originClickPipeId, *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) } if mm_want_ptrs.request != nil && !minimock.Equal(*mm_want_ptrs.request, mm_got.request) { - mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameter request, want: %#v, got: %#v%s\n", *mm_want_ptrs.request, mm_got.request, minimock.Diff(*mm_want_ptrs.request, mm_got.request)) + mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameter request, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmScalingClickPipe.ScalingClickPipeMock.defaultExpectation.expectationOrigins.originRequest, *mm_want_ptrs.request, mm_got.request, minimock.Diff(*mm_want_ptrs.request, mm_got.request)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmScalingClickPipe.t.Errorf("ClientMock.ScalingClickPipe got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmScalingClickPipe.ScalingClickPipeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmScalingClickPipe.ScalingClickPipeMock.defaultExpectation.results @@ -11018,7 +13694,7 @@ func (m *ClientMock) MinimockScalingClickPipeDone() bool { func (m *ClientMock) MinimockScalingClickPipeInspect() { for _, e := range m.ScalingClickPipeMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.ScalingClickPipe with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.ScalingClickPipe at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -11026,19 +13702,19 @@ func (m *ClientMock) MinimockScalingClickPipeInspect() { // if default expectation was set then invocations count should be greater than zero if m.ScalingClickPipeMock.defaultExpectation != nil && afterScalingClickPipeCounter < 1 { if m.ScalingClickPipeMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.ScalingClickPipe") + m.t.Errorf("Expected call to ClientMock.ScalingClickPipe at\n%s", m.ScalingClickPipeMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.ScalingClickPipe with params: %#v", *m.ScalingClickPipeMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.ScalingClickPipe at\n%s with params: %#v", m.ScalingClickPipeMock.defaultExpectation.expectationOrigins.origin, *m.ScalingClickPipeMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcScalingClickPipe != nil && afterScalingClickPipeCounter < 1 { - m.t.Error("Expected call to ClientMock.ScalingClickPipe") + m.t.Errorf("Expected call to ClientMock.ScalingClickPipe at\n%s", m.funcScalingClickPipeOrigin) } if !m.ScalingClickPipeMock.invocationsDone() && afterScalingClickPipeCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.ScalingClickPipe but found %d calls", - mm_atomic.LoadUint64(&m.ScalingClickPipeMock.expectedInvocations), afterScalingClickPipeCounter) + m.t.Errorf("Expected %d calls to ClientMock.ScalingClickPipe at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.ScalingClickPipeMock.expectedInvocations), m.ScalingClickPipeMock.expectedInvocationsOrigin, afterScalingClickPipeCounter) } } @@ -11051,16 +13727,19 @@ type mClientMockSyncDatabase struct { callArgs []*ClientMockSyncDatabaseParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockSyncDatabaseExpectation specifies expectation struct of the Client.SyncDatabase type ClientMockSyncDatabaseExpectation struct { - mock *ClientMock - params *ClientMockSyncDatabaseParams - paramPtrs *ClientMockSyncDatabaseParamPtrs - results *ClientMockSyncDatabaseResults - Counter uint64 + mock *ClientMock + params *ClientMockSyncDatabaseParams + paramPtrs *ClientMockSyncDatabaseParamPtrs + expectationOrigins ClientMockSyncDatabaseExpectationOrigins + results *ClientMockSyncDatabaseResults + returnOrigin string + Counter uint64 } // ClientMockSyncDatabaseParams contains parameters of the Client.SyncDatabase @@ -11082,6 +13761,14 @@ type ClientMockSyncDatabaseResults struct { err error } +// ClientMockSyncDatabaseOrigins contains origins of expectations of the Client.SyncDatabase +type ClientMockSyncDatabaseExpectationOrigins struct { + origin string + originCtx string + originServiceID string + originDb string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -11107,6 +13794,7 @@ func (mmSyncDatabase *mClientMockSyncDatabase) Expect(ctx context.Context, servi } mmSyncDatabase.defaultExpectation.params = &ClientMockSyncDatabaseParams{ctx, serviceID, db} + mmSyncDatabase.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmSyncDatabase.expectations { if minimock.Equal(e.params, mmSyncDatabase.defaultExpectation.params) { mmSyncDatabase.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmSyncDatabase.defaultExpectation.params) @@ -11134,6 +13822,7 @@ func (mmSyncDatabase *mClientMockSyncDatabase) ExpectCtxParam1(ctx context.Conte mmSyncDatabase.defaultExpectation.paramPtrs = &ClientMockSyncDatabaseParamPtrs{} } mmSyncDatabase.defaultExpectation.paramPtrs.ctx = &ctx + mmSyncDatabase.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmSyncDatabase } @@ -11156,6 +13845,7 @@ func (mmSyncDatabase *mClientMockSyncDatabase) ExpectServiceIDParam2(serviceID s mmSyncDatabase.defaultExpectation.paramPtrs = &ClientMockSyncDatabaseParamPtrs{} } mmSyncDatabase.defaultExpectation.paramPtrs.serviceID = &serviceID + mmSyncDatabase.defaultExpectation.expectationOrigins.originServiceID = minimock.CallerInfo(1) return mmSyncDatabase } @@ -11178,6 +13868,7 @@ func (mmSyncDatabase *mClientMockSyncDatabase) ExpectDbParam3(db Database) *mCli mmSyncDatabase.defaultExpectation.paramPtrs = &ClientMockSyncDatabaseParamPtrs{} } mmSyncDatabase.defaultExpectation.paramPtrs.db = &db + mmSyncDatabase.defaultExpectation.expectationOrigins.originDb = minimock.CallerInfo(1) return mmSyncDatabase } @@ -11203,6 +13894,7 @@ func (mmSyncDatabase *mClientMockSyncDatabase) Return(err error) *ClientMock { mmSyncDatabase.defaultExpectation = &ClientMockSyncDatabaseExpectation{mock: mmSyncDatabase.mock} } mmSyncDatabase.defaultExpectation.results = &ClientMockSyncDatabaseResults{err} + mmSyncDatabase.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmSyncDatabase.mock } @@ -11217,6 +13909,7 @@ func (mmSyncDatabase *mClientMockSyncDatabase) Set(f func(ctx context.Context, s } mmSyncDatabase.mock.funcSyncDatabase = f + mmSyncDatabase.mock.funcSyncDatabaseOrigin = minimock.CallerInfo(1) return mmSyncDatabase.mock } @@ -11228,8 +13921,9 @@ func (mmSyncDatabase *mClientMockSyncDatabase) When(ctx context.Context, service } expectation := &ClientMockSyncDatabaseExpectation{ - mock: mmSyncDatabase.mock, - params: &ClientMockSyncDatabaseParams{ctx, serviceID, db}, + mock: mmSyncDatabase.mock, + params: &ClientMockSyncDatabaseParams{ctx, serviceID, db}, + expectationOrigins: ClientMockSyncDatabaseExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmSyncDatabase.expectations = append(mmSyncDatabase.expectations, expectation) return expectation @@ -11247,6 +13941,7 @@ func (mmSyncDatabase *mClientMockSyncDatabase) Times(n uint64) *mClientMockSyncD mmSyncDatabase.mock.t.Fatalf("Times of ClientMock.SyncDatabase mock can not be zero") } mm_atomic.StoreUint64(&mmSyncDatabase.expectedInvocations, n) + mmSyncDatabase.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmSyncDatabase } @@ -11266,6 +13961,8 @@ func (mmSyncDatabase *ClientMock) SyncDatabase(ctx context.Context, serviceID st mm_atomic.AddUint64(&mmSyncDatabase.beforeSyncDatabaseCounter, 1) defer mm_atomic.AddUint64(&mmSyncDatabase.afterSyncDatabaseCounter, 1) + mmSyncDatabase.t.Helper() + if mmSyncDatabase.inspectFuncSyncDatabase != nil { mmSyncDatabase.inspectFuncSyncDatabase(ctx, serviceID, db) } @@ -11294,19 +13991,23 @@ func (mmSyncDatabase *ClientMock) SyncDatabase(ctx context.Context, serviceID st if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmSyncDatabase.t.Errorf("ClientMock.SyncDatabase got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmSyncDatabase.t.Errorf("ClientMock.SyncDatabase got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmSyncDatabase.SyncDatabaseMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceID != nil && !minimock.Equal(*mm_want_ptrs.serviceID, mm_got.serviceID) { - mmSyncDatabase.t.Errorf("ClientMock.SyncDatabase got unexpected parameter serviceID, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) + mmSyncDatabase.t.Errorf("ClientMock.SyncDatabase got unexpected parameter serviceID, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmSyncDatabase.SyncDatabaseMock.defaultExpectation.expectationOrigins.originServiceID, *mm_want_ptrs.serviceID, mm_got.serviceID, minimock.Diff(*mm_want_ptrs.serviceID, mm_got.serviceID)) } if mm_want_ptrs.db != nil && !minimock.Equal(*mm_want_ptrs.db, mm_got.db) { - mmSyncDatabase.t.Errorf("ClientMock.SyncDatabase got unexpected parameter db, want: %#v, got: %#v%s\n", *mm_want_ptrs.db, mm_got.db, minimock.Diff(*mm_want_ptrs.db, mm_got.db)) + mmSyncDatabase.t.Errorf("ClientMock.SyncDatabase got unexpected parameter db, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmSyncDatabase.SyncDatabaseMock.defaultExpectation.expectationOrigins.originDb, *mm_want_ptrs.db, mm_got.db, minimock.Diff(*mm_want_ptrs.db, mm_got.db)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmSyncDatabase.t.Errorf("ClientMock.SyncDatabase got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmSyncDatabase.t.Errorf("ClientMock.SyncDatabase got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmSyncDatabase.SyncDatabaseMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmSyncDatabase.SyncDatabaseMock.defaultExpectation.results @@ -11366,7 +14067,7 @@ func (m *ClientMock) MinimockSyncDatabaseDone() bool { func (m *ClientMock) MinimockSyncDatabaseInspect() { for _, e := range m.SyncDatabaseMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.SyncDatabase with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.SyncDatabase at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -11374,19 +14075,19 @@ func (m *ClientMock) MinimockSyncDatabaseInspect() { // if default expectation was set then invocations count should be greater than zero if m.SyncDatabaseMock.defaultExpectation != nil && afterSyncDatabaseCounter < 1 { if m.SyncDatabaseMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.SyncDatabase") + m.t.Errorf("Expected call to ClientMock.SyncDatabase at\n%s", m.SyncDatabaseMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.SyncDatabase with params: %#v", *m.SyncDatabaseMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.SyncDatabase at\n%s with params: %#v", m.SyncDatabaseMock.defaultExpectation.expectationOrigins.origin, *m.SyncDatabaseMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcSyncDatabase != nil && afterSyncDatabaseCounter < 1 { - m.t.Error("Expected call to ClientMock.SyncDatabase") + m.t.Errorf("Expected call to ClientMock.SyncDatabase at\n%s", m.funcSyncDatabaseOrigin) } if !m.SyncDatabaseMock.invocationsDone() && afterSyncDatabaseCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.SyncDatabase but found %d calls", - mm_atomic.LoadUint64(&m.SyncDatabaseMock.expectedInvocations), afterSyncDatabaseCounter) + m.t.Errorf("Expected %d calls to ClientMock.SyncDatabase at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.SyncDatabaseMock.expectedInvocations), m.SyncDatabaseMock.expectedInvocationsOrigin, afterSyncDatabaseCounter) } } @@ -11399,16 +14100,19 @@ type mClientMockUpdateBackupConfiguration struct { callArgs []*ClientMockUpdateBackupConfigurationParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockUpdateBackupConfigurationExpectation specifies expectation struct of the Client.UpdateBackupConfiguration type ClientMockUpdateBackupConfigurationExpectation struct { - mock *ClientMock - params *ClientMockUpdateBackupConfigurationParams - paramPtrs *ClientMockUpdateBackupConfigurationParamPtrs - results *ClientMockUpdateBackupConfigurationResults - Counter uint64 + mock *ClientMock + params *ClientMockUpdateBackupConfigurationParams + paramPtrs *ClientMockUpdateBackupConfigurationParamPtrs + expectationOrigins ClientMockUpdateBackupConfigurationExpectationOrigins + results *ClientMockUpdateBackupConfigurationResults + returnOrigin string + Counter uint64 } // ClientMockUpdateBackupConfigurationParams contains parameters of the Client.UpdateBackupConfiguration @@ -11431,6 +14135,14 @@ type ClientMockUpdateBackupConfigurationResults struct { err error } +// ClientMockUpdateBackupConfigurationOrigins contains origins of expectations of the Client.UpdateBackupConfiguration +type ClientMockUpdateBackupConfigurationExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originB string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -11456,6 +14168,7 @@ func (mmUpdateBackupConfiguration *mClientMockUpdateBackupConfiguration) Expect( } mmUpdateBackupConfiguration.defaultExpectation.params = &ClientMockUpdateBackupConfigurationParams{ctx, serviceId, b} + mmUpdateBackupConfiguration.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmUpdateBackupConfiguration.expectations { if minimock.Equal(e.params, mmUpdateBackupConfiguration.defaultExpectation.params) { mmUpdateBackupConfiguration.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateBackupConfiguration.defaultExpectation.params) @@ -11483,6 +14196,7 @@ func (mmUpdateBackupConfiguration *mClientMockUpdateBackupConfiguration) ExpectC mmUpdateBackupConfiguration.defaultExpectation.paramPtrs = &ClientMockUpdateBackupConfigurationParamPtrs{} } mmUpdateBackupConfiguration.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateBackupConfiguration.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmUpdateBackupConfiguration } @@ -11505,6 +14219,7 @@ func (mmUpdateBackupConfiguration *mClientMockUpdateBackupConfiguration) ExpectS mmUpdateBackupConfiguration.defaultExpectation.paramPtrs = &ClientMockUpdateBackupConfigurationParamPtrs{} } mmUpdateBackupConfiguration.defaultExpectation.paramPtrs.serviceId = &serviceId + mmUpdateBackupConfiguration.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmUpdateBackupConfiguration } @@ -11527,6 +14242,7 @@ func (mmUpdateBackupConfiguration *mClientMockUpdateBackupConfiguration) ExpectB mmUpdateBackupConfiguration.defaultExpectation.paramPtrs = &ClientMockUpdateBackupConfigurationParamPtrs{} } mmUpdateBackupConfiguration.defaultExpectation.paramPtrs.b = &b + mmUpdateBackupConfiguration.defaultExpectation.expectationOrigins.originB = minimock.CallerInfo(1) return mmUpdateBackupConfiguration } @@ -11552,6 +14268,7 @@ func (mmUpdateBackupConfiguration *mClientMockUpdateBackupConfiguration) Return( mmUpdateBackupConfiguration.defaultExpectation = &ClientMockUpdateBackupConfigurationExpectation{mock: mmUpdateBackupConfiguration.mock} } mmUpdateBackupConfiguration.defaultExpectation.results = &ClientMockUpdateBackupConfigurationResults{bp1, err} + mmUpdateBackupConfiguration.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmUpdateBackupConfiguration.mock } @@ -11566,6 +14283,7 @@ func (mmUpdateBackupConfiguration *mClientMockUpdateBackupConfiguration) Set(f f } mmUpdateBackupConfiguration.mock.funcUpdateBackupConfiguration = f + mmUpdateBackupConfiguration.mock.funcUpdateBackupConfigurationOrigin = minimock.CallerInfo(1) return mmUpdateBackupConfiguration.mock } @@ -11577,8 +14295,9 @@ func (mmUpdateBackupConfiguration *mClientMockUpdateBackupConfiguration) When(ct } expectation := &ClientMockUpdateBackupConfigurationExpectation{ - mock: mmUpdateBackupConfiguration.mock, - params: &ClientMockUpdateBackupConfigurationParams{ctx, serviceId, b}, + mock: mmUpdateBackupConfiguration.mock, + params: &ClientMockUpdateBackupConfigurationParams{ctx, serviceId, b}, + expectationOrigins: ClientMockUpdateBackupConfigurationExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmUpdateBackupConfiguration.expectations = append(mmUpdateBackupConfiguration.expectations, expectation) return expectation @@ -11596,6 +14315,7 @@ func (mmUpdateBackupConfiguration *mClientMockUpdateBackupConfiguration) Times(n mmUpdateBackupConfiguration.mock.t.Fatalf("Times of ClientMock.UpdateBackupConfiguration mock can not be zero") } mm_atomic.StoreUint64(&mmUpdateBackupConfiguration.expectedInvocations, n) + mmUpdateBackupConfiguration.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmUpdateBackupConfiguration } @@ -11615,6 +14335,8 @@ func (mmUpdateBackupConfiguration *ClientMock) UpdateBackupConfiguration(ctx con mm_atomic.AddUint64(&mmUpdateBackupConfiguration.beforeUpdateBackupConfigurationCounter, 1) defer mm_atomic.AddUint64(&mmUpdateBackupConfiguration.afterUpdateBackupConfigurationCounter, 1) + mmUpdateBackupConfiguration.t.Helper() + if mmUpdateBackupConfiguration.inspectFuncUpdateBackupConfiguration != nil { mmUpdateBackupConfiguration.inspectFuncUpdateBackupConfiguration(ctx, serviceId, b) } @@ -11643,19 +14365,23 @@ func (mmUpdateBackupConfiguration *ClientMock) UpdateBackupConfiguration(ctx con if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateBackupConfiguration.t.Errorf("ClientMock.UpdateBackupConfiguration got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateBackupConfiguration.t.Errorf("ClientMock.UpdateBackupConfiguration got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateBackupConfiguration.UpdateBackupConfigurationMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmUpdateBackupConfiguration.t.Errorf("ClientMock.UpdateBackupConfiguration got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmUpdateBackupConfiguration.t.Errorf("ClientMock.UpdateBackupConfiguration got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateBackupConfiguration.UpdateBackupConfigurationMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.b != nil && !minimock.Equal(*mm_want_ptrs.b, mm_got.b) { - mmUpdateBackupConfiguration.t.Errorf("ClientMock.UpdateBackupConfiguration got unexpected parameter b, want: %#v, got: %#v%s\n", *mm_want_ptrs.b, mm_got.b, minimock.Diff(*mm_want_ptrs.b, mm_got.b)) + mmUpdateBackupConfiguration.t.Errorf("ClientMock.UpdateBackupConfiguration got unexpected parameter b, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateBackupConfiguration.UpdateBackupConfigurationMock.defaultExpectation.expectationOrigins.originB, *mm_want_ptrs.b, mm_got.b, minimock.Diff(*mm_want_ptrs.b, mm_got.b)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateBackupConfiguration.t.Errorf("ClientMock.UpdateBackupConfiguration got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateBackupConfiguration.t.Errorf("ClientMock.UpdateBackupConfiguration got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateBackupConfiguration.UpdateBackupConfigurationMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmUpdateBackupConfiguration.UpdateBackupConfigurationMock.defaultExpectation.results @@ -11715,7 +14441,7 @@ func (m *ClientMock) MinimockUpdateBackupConfigurationDone() bool { func (m *ClientMock) MinimockUpdateBackupConfigurationInspect() { for _, e := range m.UpdateBackupConfigurationMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.UpdateBackupConfiguration with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.UpdateBackupConfiguration at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -11723,19 +14449,19 @@ func (m *ClientMock) MinimockUpdateBackupConfigurationInspect() { // if default expectation was set then invocations count should be greater than zero if m.UpdateBackupConfigurationMock.defaultExpectation != nil && afterUpdateBackupConfigurationCounter < 1 { if m.UpdateBackupConfigurationMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.UpdateBackupConfiguration") + m.t.Errorf("Expected call to ClientMock.UpdateBackupConfiguration at\n%s", m.UpdateBackupConfigurationMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.UpdateBackupConfiguration with params: %#v", *m.UpdateBackupConfigurationMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.UpdateBackupConfiguration at\n%s with params: %#v", m.UpdateBackupConfigurationMock.defaultExpectation.expectationOrigins.origin, *m.UpdateBackupConfigurationMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcUpdateBackupConfiguration != nil && afterUpdateBackupConfigurationCounter < 1 { - m.t.Error("Expected call to ClientMock.UpdateBackupConfiguration") + m.t.Errorf("Expected call to ClientMock.UpdateBackupConfiguration at\n%s", m.funcUpdateBackupConfigurationOrigin) } if !m.UpdateBackupConfigurationMock.invocationsDone() && afterUpdateBackupConfigurationCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.UpdateBackupConfiguration but found %d calls", - mm_atomic.LoadUint64(&m.UpdateBackupConfigurationMock.expectedInvocations), afterUpdateBackupConfigurationCounter) + m.t.Errorf("Expected %d calls to ClientMock.UpdateBackupConfiguration at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateBackupConfigurationMock.expectedInvocations), m.UpdateBackupConfigurationMock.expectedInvocationsOrigin, afterUpdateBackupConfigurationCounter) } } @@ -11748,16 +14474,19 @@ type mClientMockUpdateClickPipe struct { callArgs []*ClientMockUpdateClickPipeParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockUpdateClickPipeExpectation specifies expectation struct of the Client.UpdateClickPipe type ClientMockUpdateClickPipeExpectation struct { - mock *ClientMock - params *ClientMockUpdateClickPipeParams - paramPtrs *ClientMockUpdateClickPipeParamPtrs - results *ClientMockUpdateClickPipeResults - Counter uint64 + mock *ClientMock + params *ClientMockUpdateClickPipeParams + paramPtrs *ClientMockUpdateClickPipeParamPtrs + expectationOrigins ClientMockUpdateClickPipeExpectationOrigins + results *ClientMockUpdateClickPipeResults + returnOrigin string + Counter uint64 } // ClientMockUpdateClickPipeParams contains parameters of the Client.UpdateClickPipe @@ -11782,6 +14511,15 @@ type ClientMockUpdateClickPipeResults struct { err error } +// ClientMockUpdateClickPipeOrigins contains origins of expectations of the Client.UpdateClickPipe +type ClientMockUpdateClickPipeExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originClickPipeId string + originRequest string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -11807,6 +14545,7 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) Expect(ctx context.Context, } mmUpdateClickPipe.defaultExpectation.params = &ClientMockUpdateClickPipeParams{ctx, serviceId, clickPipeId, request} + mmUpdateClickPipe.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmUpdateClickPipe.expectations { if minimock.Equal(e.params, mmUpdateClickPipe.defaultExpectation.params) { mmUpdateClickPipe.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateClickPipe.defaultExpectation.params) @@ -11834,6 +14573,7 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) ExpectCtxParam1(ctx context mmUpdateClickPipe.defaultExpectation.paramPtrs = &ClientMockUpdateClickPipeParamPtrs{} } mmUpdateClickPipe.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateClickPipe.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmUpdateClickPipe } @@ -11856,6 +14596,7 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) ExpectServiceIdParam2(servi mmUpdateClickPipe.defaultExpectation.paramPtrs = &ClientMockUpdateClickPipeParamPtrs{} } mmUpdateClickPipe.defaultExpectation.paramPtrs.serviceId = &serviceId + mmUpdateClickPipe.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmUpdateClickPipe } @@ -11878,6 +14619,7 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) ExpectClickPipeIdParam3(cli mmUpdateClickPipe.defaultExpectation.paramPtrs = &ClientMockUpdateClickPipeParamPtrs{} } mmUpdateClickPipe.defaultExpectation.paramPtrs.clickPipeId = &clickPipeId + mmUpdateClickPipe.defaultExpectation.expectationOrigins.originClickPipeId = minimock.CallerInfo(1) return mmUpdateClickPipe } @@ -11900,6 +14642,7 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) ExpectRequestParam4(request mmUpdateClickPipe.defaultExpectation.paramPtrs = &ClientMockUpdateClickPipeParamPtrs{} } mmUpdateClickPipe.defaultExpectation.paramPtrs.request = &request + mmUpdateClickPipe.defaultExpectation.expectationOrigins.originRequest = minimock.CallerInfo(1) return mmUpdateClickPipe } @@ -11925,6 +14668,7 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) Return(cp1 *ClickPipe, err mmUpdateClickPipe.defaultExpectation = &ClientMockUpdateClickPipeExpectation{mock: mmUpdateClickPipe.mock} } mmUpdateClickPipe.defaultExpectation.results = &ClientMockUpdateClickPipeResults{cp1, err} + mmUpdateClickPipe.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmUpdateClickPipe.mock } @@ -11939,6 +14683,7 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) Set(f func(ctx context.Cont } mmUpdateClickPipe.mock.funcUpdateClickPipe = f + mmUpdateClickPipe.mock.funcUpdateClickPipeOrigin = minimock.CallerInfo(1) return mmUpdateClickPipe.mock } @@ -11950,8 +14695,9 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) When(ctx context.Context, s } expectation := &ClientMockUpdateClickPipeExpectation{ - mock: mmUpdateClickPipe.mock, - params: &ClientMockUpdateClickPipeParams{ctx, serviceId, clickPipeId, request}, + mock: mmUpdateClickPipe.mock, + params: &ClientMockUpdateClickPipeParams{ctx, serviceId, clickPipeId, request}, + expectationOrigins: ClientMockUpdateClickPipeExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmUpdateClickPipe.expectations = append(mmUpdateClickPipe.expectations, expectation) return expectation @@ -11969,6 +14715,7 @@ func (mmUpdateClickPipe *mClientMockUpdateClickPipe) Times(n uint64) *mClientMoc mmUpdateClickPipe.mock.t.Fatalf("Times of ClientMock.UpdateClickPipe mock can not be zero") } mm_atomic.StoreUint64(&mmUpdateClickPipe.expectedInvocations, n) + mmUpdateClickPipe.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmUpdateClickPipe } @@ -11988,6 +14735,8 @@ func (mmUpdateClickPipe *ClientMock) UpdateClickPipe(ctx context.Context, servic mm_atomic.AddUint64(&mmUpdateClickPipe.beforeUpdateClickPipeCounter, 1) defer mm_atomic.AddUint64(&mmUpdateClickPipe.afterUpdateClickPipeCounter, 1) + mmUpdateClickPipe.t.Helper() + if mmUpdateClickPipe.inspectFuncUpdateClickPipe != nil { mmUpdateClickPipe.inspectFuncUpdateClickPipe(ctx, serviceId, clickPipeId, request) } @@ -12016,23 +14765,28 @@ func (mmUpdateClickPipe *ClientMock) UpdateClickPipe(ctx context.Context, servic if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateClickPipe.UpdateClickPipeMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateClickPipe.UpdateClickPipeMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.clickPipeId != nil && !minimock.Equal(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId) { - mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameter clickPipeId, want: %#v, got: %#v%s\n", *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) + mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameter clickPipeId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateClickPipe.UpdateClickPipeMock.defaultExpectation.expectationOrigins.originClickPipeId, *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) } if mm_want_ptrs.request != nil && !minimock.Equal(*mm_want_ptrs.request, mm_got.request) { - mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameter request, want: %#v, got: %#v%s\n", *mm_want_ptrs.request, mm_got.request, minimock.Diff(*mm_want_ptrs.request, mm_got.request)) + mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameter request, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateClickPipe.UpdateClickPipeMock.defaultExpectation.expectationOrigins.originRequest, *mm_want_ptrs.request, mm_got.request, minimock.Diff(*mm_want_ptrs.request, mm_got.request)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateClickPipe.t.Errorf("ClientMock.UpdateClickPipe got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateClickPipe.UpdateClickPipeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmUpdateClickPipe.UpdateClickPipeMock.defaultExpectation.results @@ -12092,7 +14846,7 @@ func (m *ClientMock) MinimockUpdateClickPipeDone() bool { func (m *ClientMock) MinimockUpdateClickPipeInspect() { for _, e := range m.UpdateClickPipeMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.UpdateClickPipe with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.UpdateClickPipe at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -12100,19 +14854,19 @@ func (m *ClientMock) MinimockUpdateClickPipeInspect() { // if default expectation was set then invocations count should be greater than zero if m.UpdateClickPipeMock.defaultExpectation != nil && afterUpdateClickPipeCounter < 1 { if m.UpdateClickPipeMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.UpdateClickPipe") + m.t.Errorf("Expected call to ClientMock.UpdateClickPipe at\n%s", m.UpdateClickPipeMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.UpdateClickPipe with params: %#v", *m.UpdateClickPipeMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.UpdateClickPipe at\n%s with params: %#v", m.UpdateClickPipeMock.defaultExpectation.expectationOrigins.origin, *m.UpdateClickPipeMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcUpdateClickPipe != nil && afterUpdateClickPipeCounter < 1 { - m.t.Error("Expected call to ClientMock.UpdateClickPipe") + m.t.Errorf("Expected call to ClientMock.UpdateClickPipe at\n%s", m.funcUpdateClickPipeOrigin) } if !m.UpdateClickPipeMock.invocationsDone() && afterUpdateClickPipeCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.UpdateClickPipe but found %d calls", - mm_atomic.LoadUint64(&m.UpdateClickPipeMock.expectedInvocations), afterUpdateClickPipeCounter) + m.t.Errorf("Expected %d calls to ClientMock.UpdateClickPipe at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateClickPipeMock.expectedInvocations), m.UpdateClickPipeMock.expectedInvocationsOrigin, afterUpdateClickPipeCounter) } } @@ -12125,16 +14879,19 @@ type mClientMockUpdateOrganizationPrivateEndpoints struct { callArgs []*ClientMockUpdateOrganizationPrivateEndpointsParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockUpdateOrganizationPrivateEndpointsExpectation specifies expectation struct of the Client.UpdateOrganizationPrivateEndpoints type ClientMockUpdateOrganizationPrivateEndpointsExpectation struct { - mock *ClientMock - params *ClientMockUpdateOrganizationPrivateEndpointsParams - paramPtrs *ClientMockUpdateOrganizationPrivateEndpointsParamPtrs - results *ClientMockUpdateOrganizationPrivateEndpointsResults - Counter uint64 + mock *ClientMock + params *ClientMockUpdateOrganizationPrivateEndpointsParams + paramPtrs *ClientMockUpdateOrganizationPrivateEndpointsParamPtrs + expectationOrigins ClientMockUpdateOrganizationPrivateEndpointsExpectationOrigins + results *ClientMockUpdateOrganizationPrivateEndpointsResults + returnOrigin string + Counter uint64 } // ClientMockUpdateOrganizationPrivateEndpointsParams contains parameters of the Client.UpdateOrganizationPrivateEndpoints @@ -12155,6 +14912,13 @@ type ClientMockUpdateOrganizationPrivateEndpointsResults struct { err error } +// ClientMockUpdateOrganizationPrivateEndpointsOrigins contains origins of expectations of the Client.UpdateOrganizationPrivateEndpoints +type ClientMockUpdateOrganizationPrivateEndpointsExpectationOrigins struct { + origin string + originCtx string + originOrgUpdate string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -12180,6 +14944,7 @@ func (mmUpdateOrganizationPrivateEndpoints *mClientMockUpdateOrganizationPrivate } mmUpdateOrganizationPrivateEndpoints.defaultExpectation.params = &ClientMockUpdateOrganizationPrivateEndpointsParams{ctx, orgUpdate} + mmUpdateOrganizationPrivateEndpoints.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmUpdateOrganizationPrivateEndpoints.expectations { if minimock.Equal(e.params, mmUpdateOrganizationPrivateEndpoints.defaultExpectation.params) { mmUpdateOrganizationPrivateEndpoints.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateOrganizationPrivateEndpoints.defaultExpectation.params) @@ -12207,6 +14972,7 @@ func (mmUpdateOrganizationPrivateEndpoints *mClientMockUpdateOrganizationPrivate mmUpdateOrganizationPrivateEndpoints.defaultExpectation.paramPtrs = &ClientMockUpdateOrganizationPrivateEndpointsParamPtrs{} } mmUpdateOrganizationPrivateEndpoints.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateOrganizationPrivateEndpoints.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmUpdateOrganizationPrivateEndpoints } @@ -12229,6 +14995,7 @@ func (mmUpdateOrganizationPrivateEndpoints *mClientMockUpdateOrganizationPrivate mmUpdateOrganizationPrivateEndpoints.defaultExpectation.paramPtrs = &ClientMockUpdateOrganizationPrivateEndpointsParamPtrs{} } mmUpdateOrganizationPrivateEndpoints.defaultExpectation.paramPtrs.orgUpdate = &orgUpdate + mmUpdateOrganizationPrivateEndpoints.defaultExpectation.expectationOrigins.originOrgUpdate = minimock.CallerInfo(1) return mmUpdateOrganizationPrivateEndpoints } @@ -12254,6 +15021,7 @@ func (mmUpdateOrganizationPrivateEndpoints *mClientMockUpdateOrganizationPrivate mmUpdateOrganizationPrivateEndpoints.defaultExpectation = &ClientMockUpdateOrganizationPrivateEndpointsExpectation{mock: mmUpdateOrganizationPrivateEndpoints.mock} } mmUpdateOrganizationPrivateEndpoints.defaultExpectation.results = &ClientMockUpdateOrganizationPrivateEndpointsResults{pap1, err} + mmUpdateOrganizationPrivateEndpoints.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmUpdateOrganizationPrivateEndpoints.mock } @@ -12268,6 +15036,7 @@ func (mmUpdateOrganizationPrivateEndpoints *mClientMockUpdateOrganizationPrivate } mmUpdateOrganizationPrivateEndpoints.mock.funcUpdateOrganizationPrivateEndpoints = f + mmUpdateOrganizationPrivateEndpoints.mock.funcUpdateOrganizationPrivateEndpointsOrigin = minimock.CallerInfo(1) return mmUpdateOrganizationPrivateEndpoints.mock } @@ -12279,8 +15048,9 @@ func (mmUpdateOrganizationPrivateEndpoints *mClientMockUpdateOrganizationPrivate } expectation := &ClientMockUpdateOrganizationPrivateEndpointsExpectation{ - mock: mmUpdateOrganizationPrivateEndpoints.mock, - params: &ClientMockUpdateOrganizationPrivateEndpointsParams{ctx, orgUpdate}, + mock: mmUpdateOrganizationPrivateEndpoints.mock, + params: &ClientMockUpdateOrganizationPrivateEndpointsParams{ctx, orgUpdate}, + expectationOrigins: ClientMockUpdateOrganizationPrivateEndpointsExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmUpdateOrganizationPrivateEndpoints.expectations = append(mmUpdateOrganizationPrivateEndpoints.expectations, expectation) return expectation @@ -12298,6 +15068,7 @@ func (mmUpdateOrganizationPrivateEndpoints *mClientMockUpdateOrganizationPrivate mmUpdateOrganizationPrivateEndpoints.mock.t.Fatalf("Times of ClientMock.UpdateOrganizationPrivateEndpoints mock can not be zero") } mm_atomic.StoreUint64(&mmUpdateOrganizationPrivateEndpoints.expectedInvocations, n) + mmUpdateOrganizationPrivateEndpoints.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmUpdateOrganizationPrivateEndpoints } @@ -12317,6 +15088,8 @@ func (mmUpdateOrganizationPrivateEndpoints *ClientMock) UpdateOrganizationPrivat mm_atomic.AddUint64(&mmUpdateOrganizationPrivateEndpoints.beforeUpdateOrganizationPrivateEndpointsCounter, 1) defer mm_atomic.AddUint64(&mmUpdateOrganizationPrivateEndpoints.afterUpdateOrganizationPrivateEndpointsCounter, 1) + mmUpdateOrganizationPrivateEndpoints.t.Helper() + if mmUpdateOrganizationPrivateEndpoints.inspectFuncUpdateOrganizationPrivateEndpoints != nil { mmUpdateOrganizationPrivateEndpoints.inspectFuncUpdateOrganizationPrivateEndpoints(ctx, orgUpdate) } @@ -12345,15 +15118,18 @@ func (mmUpdateOrganizationPrivateEndpoints *ClientMock) UpdateOrganizationPrivat if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateOrganizationPrivateEndpoints.t.Errorf("ClientMock.UpdateOrganizationPrivateEndpoints got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateOrganizationPrivateEndpoints.t.Errorf("ClientMock.UpdateOrganizationPrivateEndpoints got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateOrganizationPrivateEndpoints.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.orgUpdate != nil && !minimock.Equal(*mm_want_ptrs.orgUpdate, mm_got.orgUpdate) { - mmUpdateOrganizationPrivateEndpoints.t.Errorf("ClientMock.UpdateOrganizationPrivateEndpoints got unexpected parameter orgUpdate, want: %#v, got: %#v%s\n", *mm_want_ptrs.orgUpdate, mm_got.orgUpdate, minimock.Diff(*mm_want_ptrs.orgUpdate, mm_got.orgUpdate)) + mmUpdateOrganizationPrivateEndpoints.t.Errorf("ClientMock.UpdateOrganizationPrivateEndpoints got unexpected parameter orgUpdate, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateOrganizationPrivateEndpoints.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.expectationOrigins.originOrgUpdate, *mm_want_ptrs.orgUpdate, mm_got.orgUpdate, minimock.Diff(*mm_want_ptrs.orgUpdate, mm_got.orgUpdate)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateOrganizationPrivateEndpoints.t.Errorf("ClientMock.UpdateOrganizationPrivateEndpoints got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateOrganizationPrivateEndpoints.t.Errorf("ClientMock.UpdateOrganizationPrivateEndpoints got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateOrganizationPrivateEndpoints.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmUpdateOrganizationPrivateEndpoints.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.results @@ -12413,7 +15189,7 @@ func (m *ClientMock) MinimockUpdateOrganizationPrivateEndpointsDone() bool { func (m *ClientMock) MinimockUpdateOrganizationPrivateEndpointsInspect() { for _, e := range m.UpdateOrganizationPrivateEndpointsMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.UpdateOrganizationPrivateEndpoints with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.UpdateOrganizationPrivateEndpoints at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -12421,19 +15197,19 @@ func (m *ClientMock) MinimockUpdateOrganizationPrivateEndpointsInspect() { // if default expectation was set then invocations count should be greater than zero if m.UpdateOrganizationPrivateEndpointsMock.defaultExpectation != nil && afterUpdateOrganizationPrivateEndpointsCounter < 1 { if m.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.UpdateOrganizationPrivateEndpoints") + m.t.Errorf("Expected call to ClientMock.UpdateOrganizationPrivateEndpoints at\n%s", m.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.UpdateOrganizationPrivateEndpoints with params: %#v", *m.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.UpdateOrganizationPrivateEndpoints at\n%s with params: %#v", m.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.expectationOrigins.origin, *m.UpdateOrganizationPrivateEndpointsMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcUpdateOrganizationPrivateEndpoints != nil && afterUpdateOrganizationPrivateEndpointsCounter < 1 { - m.t.Error("Expected call to ClientMock.UpdateOrganizationPrivateEndpoints") + m.t.Errorf("Expected call to ClientMock.UpdateOrganizationPrivateEndpoints at\n%s", m.funcUpdateOrganizationPrivateEndpointsOrigin) } if !m.UpdateOrganizationPrivateEndpointsMock.invocationsDone() && afterUpdateOrganizationPrivateEndpointsCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.UpdateOrganizationPrivateEndpoints but found %d calls", - mm_atomic.LoadUint64(&m.UpdateOrganizationPrivateEndpointsMock.expectedInvocations), afterUpdateOrganizationPrivateEndpointsCounter) + m.t.Errorf("Expected %d calls to ClientMock.UpdateOrganizationPrivateEndpoints at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateOrganizationPrivateEndpointsMock.expectedInvocations), m.UpdateOrganizationPrivateEndpointsMock.expectedInvocationsOrigin, afterUpdateOrganizationPrivateEndpointsCounter) } } @@ -12446,16 +15222,19 @@ type mClientMockUpdateReplicaScaling struct { callArgs []*ClientMockUpdateReplicaScalingParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockUpdateReplicaScalingExpectation specifies expectation struct of the Client.UpdateReplicaScaling type ClientMockUpdateReplicaScalingExpectation struct { - mock *ClientMock - params *ClientMockUpdateReplicaScalingParams - paramPtrs *ClientMockUpdateReplicaScalingParamPtrs - results *ClientMockUpdateReplicaScalingResults - Counter uint64 + mock *ClientMock + params *ClientMockUpdateReplicaScalingParams + paramPtrs *ClientMockUpdateReplicaScalingParamPtrs + expectationOrigins ClientMockUpdateReplicaScalingExpectationOrigins + results *ClientMockUpdateReplicaScalingResults + returnOrigin string + Counter uint64 } // ClientMockUpdateReplicaScalingParams contains parameters of the Client.UpdateReplicaScaling @@ -12478,6 +15257,14 @@ type ClientMockUpdateReplicaScalingResults struct { err error } +// ClientMockUpdateReplicaScalingOrigins contains origins of expectations of the Client.UpdateReplicaScaling +type ClientMockUpdateReplicaScalingExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originS string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -12503,6 +15290,7 @@ func (mmUpdateReplicaScaling *mClientMockUpdateReplicaScaling) Expect(ctx contex } mmUpdateReplicaScaling.defaultExpectation.params = &ClientMockUpdateReplicaScalingParams{ctx, serviceId, s} + mmUpdateReplicaScaling.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmUpdateReplicaScaling.expectations { if minimock.Equal(e.params, mmUpdateReplicaScaling.defaultExpectation.params) { mmUpdateReplicaScaling.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateReplicaScaling.defaultExpectation.params) @@ -12530,6 +15318,7 @@ func (mmUpdateReplicaScaling *mClientMockUpdateReplicaScaling) ExpectCtxParam1(c mmUpdateReplicaScaling.defaultExpectation.paramPtrs = &ClientMockUpdateReplicaScalingParamPtrs{} } mmUpdateReplicaScaling.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateReplicaScaling.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmUpdateReplicaScaling } @@ -12552,6 +15341,7 @@ func (mmUpdateReplicaScaling *mClientMockUpdateReplicaScaling) ExpectServiceIdPa mmUpdateReplicaScaling.defaultExpectation.paramPtrs = &ClientMockUpdateReplicaScalingParamPtrs{} } mmUpdateReplicaScaling.defaultExpectation.paramPtrs.serviceId = &serviceId + mmUpdateReplicaScaling.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmUpdateReplicaScaling } @@ -12574,6 +15364,7 @@ func (mmUpdateReplicaScaling *mClientMockUpdateReplicaScaling) ExpectSParam3(s R mmUpdateReplicaScaling.defaultExpectation.paramPtrs = &ClientMockUpdateReplicaScalingParamPtrs{} } mmUpdateReplicaScaling.defaultExpectation.paramPtrs.s = &s + mmUpdateReplicaScaling.defaultExpectation.expectationOrigins.originS = minimock.CallerInfo(1) return mmUpdateReplicaScaling } @@ -12599,6 +15390,7 @@ func (mmUpdateReplicaScaling *mClientMockUpdateReplicaScaling) Return(sp1 *Servi mmUpdateReplicaScaling.defaultExpectation = &ClientMockUpdateReplicaScalingExpectation{mock: mmUpdateReplicaScaling.mock} } mmUpdateReplicaScaling.defaultExpectation.results = &ClientMockUpdateReplicaScalingResults{sp1, err} + mmUpdateReplicaScaling.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmUpdateReplicaScaling.mock } @@ -12613,6 +15405,7 @@ func (mmUpdateReplicaScaling *mClientMockUpdateReplicaScaling) Set(f func(ctx co } mmUpdateReplicaScaling.mock.funcUpdateReplicaScaling = f + mmUpdateReplicaScaling.mock.funcUpdateReplicaScalingOrigin = minimock.CallerInfo(1) return mmUpdateReplicaScaling.mock } @@ -12624,8 +15417,9 @@ func (mmUpdateReplicaScaling *mClientMockUpdateReplicaScaling) When(ctx context. } expectation := &ClientMockUpdateReplicaScalingExpectation{ - mock: mmUpdateReplicaScaling.mock, - params: &ClientMockUpdateReplicaScalingParams{ctx, serviceId, s}, + mock: mmUpdateReplicaScaling.mock, + params: &ClientMockUpdateReplicaScalingParams{ctx, serviceId, s}, + expectationOrigins: ClientMockUpdateReplicaScalingExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmUpdateReplicaScaling.expectations = append(mmUpdateReplicaScaling.expectations, expectation) return expectation @@ -12643,6 +15437,7 @@ func (mmUpdateReplicaScaling *mClientMockUpdateReplicaScaling) Times(n uint64) * mmUpdateReplicaScaling.mock.t.Fatalf("Times of ClientMock.UpdateReplicaScaling mock can not be zero") } mm_atomic.StoreUint64(&mmUpdateReplicaScaling.expectedInvocations, n) + mmUpdateReplicaScaling.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmUpdateReplicaScaling } @@ -12662,6 +15457,8 @@ func (mmUpdateReplicaScaling *ClientMock) UpdateReplicaScaling(ctx context.Conte mm_atomic.AddUint64(&mmUpdateReplicaScaling.beforeUpdateReplicaScalingCounter, 1) defer mm_atomic.AddUint64(&mmUpdateReplicaScaling.afterUpdateReplicaScalingCounter, 1) + mmUpdateReplicaScaling.t.Helper() + if mmUpdateReplicaScaling.inspectFuncUpdateReplicaScaling != nil { mmUpdateReplicaScaling.inspectFuncUpdateReplicaScaling(ctx, serviceId, s) } @@ -12690,19 +15487,23 @@ func (mmUpdateReplicaScaling *ClientMock) UpdateReplicaScaling(ctx context.Conte if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateReplicaScaling.t.Errorf("ClientMock.UpdateReplicaScaling got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateReplicaScaling.t.Errorf("ClientMock.UpdateReplicaScaling got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateReplicaScaling.UpdateReplicaScalingMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmUpdateReplicaScaling.t.Errorf("ClientMock.UpdateReplicaScaling got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmUpdateReplicaScaling.t.Errorf("ClientMock.UpdateReplicaScaling got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateReplicaScaling.UpdateReplicaScalingMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.s != nil && !minimock.Equal(*mm_want_ptrs.s, mm_got.s) { - mmUpdateReplicaScaling.t.Errorf("ClientMock.UpdateReplicaScaling got unexpected parameter s, want: %#v, got: %#v%s\n", *mm_want_ptrs.s, mm_got.s, minimock.Diff(*mm_want_ptrs.s, mm_got.s)) + mmUpdateReplicaScaling.t.Errorf("ClientMock.UpdateReplicaScaling got unexpected parameter s, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateReplicaScaling.UpdateReplicaScalingMock.defaultExpectation.expectationOrigins.originS, *mm_want_ptrs.s, mm_got.s, minimock.Diff(*mm_want_ptrs.s, mm_got.s)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateReplicaScaling.t.Errorf("ClientMock.UpdateReplicaScaling got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateReplicaScaling.t.Errorf("ClientMock.UpdateReplicaScaling got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateReplicaScaling.UpdateReplicaScalingMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmUpdateReplicaScaling.UpdateReplicaScalingMock.defaultExpectation.results @@ -12762,7 +15563,7 @@ func (m *ClientMock) MinimockUpdateReplicaScalingDone() bool { func (m *ClientMock) MinimockUpdateReplicaScalingInspect() { for _, e := range m.UpdateReplicaScalingMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.UpdateReplicaScaling with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.UpdateReplicaScaling at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -12770,19 +15571,19 @@ func (m *ClientMock) MinimockUpdateReplicaScalingInspect() { // if default expectation was set then invocations count should be greater than zero if m.UpdateReplicaScalingMock.defaultExpectation != nil && afterUpdateReplicaScalingCounter < 1 { if m.UpdateReplicaScalingMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.UpdateReplicaScaling") + m.t.Errorf("Expected call to ClientMock.UpdateReplicaScaling at\n%s", m.UpdateReplicaScalingMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.UpdateReplicaScaling with params: %#v", *m.UpdateReplicaScalingMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.UpdateReplicaScaling at\n%s with params: %#v", m.UpdateReplicaScalingMock.defaultExpectation.expectationOrigins.origin, *m.UpdateReplicaScalingMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcUpdateReplicaScaling != nil && afterUpdateReplicaScalingCounter < 1 { - m.t.Error("Expected call to ClientMock.UpdateReplicaScaling") + m.t.Errorf("Expected call to ClientMock.UpdateReplicaScaling at\n%s", m.funcUpdateReplicaScalingOrigin) } if !m.UpdateReplicaScalingMock.invocationsDone() && afterUpdateReplicaScalingCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.UpdateReplicaScaling but found %d calls", - mm_atomic.LoadUint64(&m.UpdateReplicaScalingMock.expectedInvocations), afterUpdateReplicaScalingCounter) + m.t.Errorf("Expected %d calls to ClientMock.UpdateReplicaScaling at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateReplicaScalingMock.expectedInvocations), m.UpdateReplicaScalingMock.expectedInvocationsOrigin, afterUpdateReplicaScalingCounter) } } @@ -12795,16 +15596,19 @@ type mClientMockUpdateService struct { callArgs []*ClientMockUpdateServiceParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockUpdateServiceExpectation specifies expectation struct of the Client.UpdateService type ClientMockUpdateServiceExpectation struct { - mock *ClientMock - params *ClientMockUpdateServiceParams - paramPtrs *ClientMockUpdateServiceParamPtrs - results *ClientMockUpdateServiceResults - Counter uint64 + mock *ClientMock + params *ClientMockUpdateServiceParams + paramPtrs *ClientMockUpdateServiceParamPtrs + expectationOrigins ClientMockUpdateServiceExpectationOrigins + results *ClientMockUpdateServiceResults + returnOrigin string + Counter uint64 } // ClientMockUpdateServiceParams contains parameters of the Client.UpdateService @@ -12827,6 +15631,14 @@ type ClientMockUpdateServiceResults struct { err error } +// ClientMockUpdateServiceOrigins contains origins of expectations of the Client.UpdateService +type ClientMockUpdateServiceExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originS string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -12852,6 +15664,7 @@ func (mmUpdateService *mClientMockUpdateService) Expect(ctx context.Context, ser } mmUpdateService.defaultExpectation.params = &ClientMockUpdateServiceParams{ctx, serviceId, s} + mmUpdateService.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmUpdateService.expectations { if minimock.Equal(e.params, mmUpdateService.defaultExpectation.params) { mmUpdateService.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateService.defaultExpectation.params) @@ -12879,6 +15692,7 @@ func (mmUpdateService *mClientMockUpdateService) ExpectCtxParam1(ctx context.Con mmUpdateService.defaultExpectation.paramPtrs = &ClientMockUpdateServiceParamPtrs{} } mmUpdateService.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateService.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmUpdateService } @@ -12901,6 +15715,7 @@ func (mmUpdateService *mClientMockUpdateService) ExpectServiceIdParam2(serviceId mmUpdateService.defaultExpectation.paramPtrs = &ClientMockUpdateServiceParamPtrs{} } mmUpdateService.defaultExpectation.paramPtrs.serviceId = &serviceId + mmUpdateService.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmUpdateService } @@ -12923,6 +15738,7 @@ func (mmUpdateService *mClientMockUpdateService) ExpectSParam3(s ServiceUpdate) mmUpdateService.defaultExpectation.paramPtrs = &ClientMockUpdateServiceParamPtrs{} } mmUpdateService.defaultExpectation.paramPtrs.s = &s + mmUpdateService.defaultExpectation.expectationOrigins.originS = minimock.CallerInfo(1) return mmUpdateService } @@ -12948,6 +15764,7 @@ func (mmUpdateService *mClientMockUpdateService) Return(sp1 *Service, err error) mmUpdateService.defaultExpectation = &ClientMockUpdateServiceExpectation{mock: mmUpdateService.mock} } mmUpdateService.defaultExpectation.results = &ClientMockUpdateServiceResults{sp1, err} + mmUpdateService.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmUpdateService.mock } @@ -12962,6 +15779,7 @@ func (mmUpdateService *mClientMockUpdateService) Set(f func(ctx context.Context, } mmUpdateService.mock.funcUpdateService = f + mmUpdateService.mock.funcUpdateServiceOrigin = minimock.CallerInfo(1) return mmUpdateService.mock } @@ -12973,8 +15791,9 @@ func (mmUpdateService *mClientMockUpdateService) When(ctx context.Context, servi } expectation := &ClientMockUpdateServiceExpectation{ - mock: mmUpdateService.mock, - params: &ClientMockUpdateServiceParams{ctx, serviceId, s}, + mock: mmUpdateService.mock, + params: &ClientMockUpdateServiceParams{ctx, serviceId, s}, + expectationOrigins: ClientMockUpdateServiceExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmUpdateService.expectations = append(mmUpdateService.expectations, expectation) return expectation @@ -12992,6 +15811,7 @@ func (mmUpdateService *mClientMockUpdateService) Times(n uint64) *mClientMockUpd mmUpdateService.mock.t.Fatalf("Times of ClientMock.UpdateService mock can not be zero") } mm_atomic.StoreUint64(&mmUpdateService.expectedInvocations, n) + mmUpdateService.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmUpdateService } @@ -13011,6 +15831,8 @@ func (mmUpdateService *ClientMock) UpdateService(ctx context.Context, serviceId mm_atomic.AddUint64(&mmUpdateService.beforeUpdateServiceCounter, 1) defer mm_atomic.AddUint64(&mmUpdateService.afterUpdateServiceCounter, 1) + mmUpdateService.t.Helper() + if mmUpdateService.inspectFuncUpdateService != nil { mmUpdateService.inspectFuncUpdateService(ctx, serviceId, s) } @@ -13039,19 +15861,23 @@ func (mmUpdateService *ClientMock) UpdateService(ctx context.Context, serviceId if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateService.t.Errorf("ClientMock.UpdateService got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateService.t.Errorf("ClientMock.UpdateService got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateService.UpdateServiceMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmUpdateService.t.Errorf("ClientMock.UpdateService got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmUpdateService.t.Errorf("ClientMock.UpdateService got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateService.UpdateServiceMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.s != nil && !minimock.Equal(*mm_want_ptrs.s, mm_got.s) { - mmUpdateService.t.Errorf("ClientMock.UpdateService got unexpected parameter s, want: %#v, got: %#v%s\n", *mm_want_ptrs.s, mm_got.s, minimock.Diff(*mm_want_ptrs.s, mm_got.s)) + mmUpdateService.t.Errorf("ClientMock.UpdateService got unexpected parameter s, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateService.UpdateServiceMock.defaultExpectation.expectationOrigins.originS, *mm_want_ptrs.s, mm_got.s, minimock.Diff(*mm_want_ptrs.s, mm_got.s)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateService.t.Errorf("ClientMock.UpdateService got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateService.t.Errorf("ClientMock.UpdateService got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateService.UpdateServiceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmUpdateService.UpdateServiceMock.defaultExpectation.results @@ -13111,7 +15937,7 @@ func (m *ClientMock) MinimockUpdateServiceDone() bool { func (m *ClientMock) MinimockUpdateServiceInspect() { for _, e := range m.UpdateServiceMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.UpdateService with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.UpdateService at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -13119,19 +15945,19 @@ func (m *ClientMock) MinimockUpdateServiceInspect() { // if default expectation was set then invocations count should be greater than zero if m.UpdateServiceMock.defaultExpectation != nil && afterUpdateServiceCounter < 1 { if m.UpdateServiceMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.UpdateService") + m.t.Errorf("Expected call to ClientMock.UpdateService at\n%s", m.UpdateServiceMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.UpdateService with params: %#v", *m.UpdateServiceMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.UpdateService at\n%s with params: %#v", m.UpdateServiceMock.defaultExpectation.expectationOrigins.origin, *m.UpdateServiceMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcUpdateService != nil && afterUpdateServiceCounter < 1 { - m.t.Error("Expected call to ClientMock.UpdateService") + m.t.Errorf("Expected call to ClientMock.UpdateService at\n%s", m.funcUpdateServiceOrigin) } if !m.UpdateServiceMock.invocationsDone() && afterUpdateServiceCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.UpdateService but found %d calls", - mm_atomic.LoadUint64(&m.UpdateServiceMock.expectedInvocations), afterUpdateServiceCounter) + m.t.Errorf("Expected %d calls to ClientMock.UpdateService at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateServiceMock.expectedInvocations), m.UpdateServiceMock.expectedInvocationsOrigin, afterUpdateServiceCounter) } } @@ -13144,16 +15970,19 @@ type mClientMockUpdateServicePassword struct { callArgs []*ClientMockUpdateServicePasswordParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockUpdateServicePasswordExpectation specifies expectation struct of the Client.UpdateServicePassword type ClientMockUpdateServicePasswordExpectation struct { - mock *ClientMock - params *ClientMockUpdateServicePasswordParams - paramPtrs *ClientMockUpdateServicePasswordParamPtrs - results *ClientMockUpdateServicePasswordResults - Counter uint64 + mock *ClientMock + params *ClientMockUpdateServicePasswordParams + paramPtrs *ClientMockUpdateServicePasswordParamPtrs + expectationOrigins ClientMockUpdateServicePasswordExpectationOrigins + results *ClientMockUpdateServicePasswordResults + returnOrigin string + Counter uint64 } // ClientMockUpdateServicePasswordParams contains parameters of the Client.UpdateServicePassword @@ -13176,6 +16005,14 @@ type ClientMockUpdateServicePasswordResults struct { err error } +// ClientMockUpdateServicePasswordOrigins contains origins of expectations of the Client.UpdateServicePassword +type ClientMockUpdateServicePasswordExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originU string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -13201,6 +16038,7 @@ func (mmUpdateServicePassword *mClientMockUpdateServicePassword) Expect(ctx cont } mmUpdateServicePassword.defaultExpectation.params = &ClientMockUpdateServicePasswordParams{ctx, serviceId, u} + mmUpdateServicePassword.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmUpdateServicePassword.expectations { if minimock.Equal(e.params, mmUpdateServicePassword.defaultExpectation.params) { mmUpdateServicePassword.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateServicePassword.defaultExpectation.params) @@ -13228,6 +16066,7 @@ func (mmUpdateServicePassword *mClientMockUpdateServicePassword) ExpectCtxParam1 mmUpdateServicePassword.defaultExpectation.paramPtrs = &ClientMockUpdateServicePasswordParamPtrs{} } mmUpdateServicePassword.defaultExpectation.paramPtrs.ctx = &ctx + mmUpdateServicePassword.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmUpdateServicePassword } @@ -13250,6 +16089,7 @@ func (mmUpdateServicePassword *mClientMockUpdateServicePassword) ExpectServiceId mmUpdateServicePassword.defaultExpectation.paramPtrs = &ClientMockUpdateServicePasswordParamPtrs{} } mmUpdateServicePassword.defaultExpectation.paramPtrs.serviceId = &serviceId + mmUpdateServicePassword.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmUpdateServicePassword } @@ -13272,6 +16112,7 @@ func (mmUpdateServicePassword *mClientMockUpdateServicePassword) ExpectUParam3(u mmUpdateServicePassword.defaultExpectation.paramPtrs = &ClientMockUpdateServicePasswordParamPtrs{} } mmUpdateServicePassword.defaultExpectation.paramPtrs.u = &u + mmUpdateServicePassword.defaultExpectation.expectationOrigins.originU = minimock.CallerInfo(1) return mmUpdateServicePassword } @@ -13297,6 +16138,7 @@ func (mmUpdateServicePassword *mClientMockUpdateServicePassword) Return(sp1 *Ser mmUpdateServicePassword.defaultExpectation = &ClientMockUpdateServicePasswordExpectation{mock: mmUpdateServicePassword.mock} } mmUpdateServicePassword.defaultExpectation.results = &ClientMockUpdateServicePasswordResults{sp1, err} + mmUpdateServicePassword.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmUpdateServicePassword.mock } @@ -13311,6 +16153,7 @@ func (mmUpdateServicePassword *mClientMockUpdateServicePassword) Set(f func(ctx } mmUpdateServicePassword.mock.funcUpdateServicePassword = f + mmUpdateServicePassword.mock.funcUpdateServicePasswordOrigin = minimock.CallerInfo(1) return mmUpdateServicePassword.mock } @@ -13322,8 +16165,9 @@ func (mmUpdateServicePassword *mClientMockUpdateServicePassword) When(ctx contex } expectation := &ClientMockUpdateServicePasswordExpectation{ - mock: mmUpdateServicePassword.mock, - params: &ClientMockUpdateServicePasswordParams{ctx, serviceId, u}, + mock: mmUpdateServicePassword.mock, + params: &ClientMockUpdateServicePasswordParams{ctx, serviceId, u}, + expectationOrigins: ClientMockUpdateServicePasswordExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmUpdateServicePassword.expectations = append(mmUpdateServicePassword.expectations, expectation) return expectation @@ -13341,6 +16185,7 @@ func (mmUpdateServicePassword *mClientMockUpdateServicePassword) Times(n uint64) mmUpdateServicePassword.mock.t.Fatalf("Times of ClientMock.UpdateServicePassword mock can not be zero") } mm_atomic.StoreUint64(&mmUpdateServicePassword.expectedInvocations, n) + mmUpdateServicePassword.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmUpdateServicePassword } @@ -13360,6 +16205,8 @@ func (mmUpdateServicePassword *ClientMock) UpdateServicePassword(ctx context.Con mm_atomic.AddUint64(&mmUpdateServicePassword.beforeUpdateServicePasswordCounter, 1) defer mm_atomic.AddUint64(&mmUpdateServicePassword.afterUpdateServicePasswordCounter, 1) + mmUpdateServicePassword.t.Helper() + if mmUpdateServicePassword.inspectFuncUpdateServicePassword != nil { mmUpdateServicePassword.inspectFuncUpdateServicePassword(ctx, serviceId, u) } @@ -13388,19 +16235,23 @@ func (mmUpdateServicePassword *ClientMock) UpdateServicePassword(ctx context.Con if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmUpdateServicePassword.t.Errorf("ClientMock.UpdateServicePassword got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmUpdateServicePassword.t.Errorf("ClientMock.UpdateServicePassword got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateServicePassword.UpdateServicePasswordMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmUpdateServicePassword.t.Errorf("ClientMock.UpdateServicePassword got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmUpdateServicePassword.t.Errorf("ClientMock.UpdateServicePassword got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateServicePassword.UpdateServicePasswordMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.u != nil && !minimock.Equal(*mm_want_ptrs.u, mm_got.u) { - mmUpdateServicePassword.t.Errorf("ClientMock.UpdateServicePassword got unexpected parameter u, want: %#v, got: %#v%s\n", *mm_want_ptrs.u, mm_got.u, minimock.Diff(*mm_want_ptrs.u, mm_got.u)) + mmUpdateServicePassword.t.Errorf("ClientMock.UpdateServicePassword got unexpected parameter u, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateServicePassword.UpdateServicePasswordMock.defaultExpectation.expectationOrigins.originU, *mm_want_ptrs.u, mm_got.u, minimock.Diff(*mm_want_ptrs.u, mm_got.u)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmUpdateServicePassword.t.Errorf("ClientMock.UpdateServicePassword got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmUpdateServicePassword.t.Errorf("ClientMock.UpdateServicePassword got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmUpdateServicePassword.UpdateServicePasswordMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmUpdateServicePassword.UpdateServicePasswordMock.defaultExpectation.results @@ -13460,7 +16311,7 @@ func (m *ClientMock) MinimockUpdateServicePasswordDone() bool { func (m *ClientMock) MinimockUpdateServicePasswordInspect() { for _, e := range m.UpdateServicePasswordMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.UpdateServicePassword with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.UpdateServicePassword at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -13468,19 +16319,19 @@ func (m *ClientMock) MinimockUpdateServicePasswordInspect() { // if default expectation was set then invocations count should be greater than zero if m.UpdateServicePasswordMock.defaultExpectation != nil && afterUpdateServicePasswordCounter < 1 { if m.UpdateServicePasswordMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.UpdateServicePassword") + m.t.Errorf("Expected call to ClientMock.UpdateServicePassword at\n%s", m.UpdateServicePasswordMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.UpdateServicePassword with params: %#v", *m.UpdateServicePasswordMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.UpdateServicePassword at\n%s with params: %#v", m.UpdateServicePasswordMock.defaultExpectation.expectationOrigins.origin, *m.UpdateServicePasswordMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcUpdateServicePassword != nil && afterUpdateServicePasswordCounter < 1 { - m.t.Error("Expected call to ClientMock.UpdateServicePassword") + m.t.Errorf("Expected call to ClientMock.UpdateServicePassword at\n%s", m.funcUpdateServicePasswordOrigin) } if !m.UpdateServicePasswordMock.invocationsDone() && afterUpdateServicePasswordCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.UpdateServicePassword but found %d calls", - mm_atomic.LoadUint64(&m.UpdateServicePasswordMock.expectedInvocations), afterUpdateServicePasswordCounter) + m.t.Errorf("Expected %d calls to ClientMock.UpdateServicePassword at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.UpdateServicePasswordMock.expectedInvocations), m.UpdateServicePasswordMock.expectedInvocationsOrigin, afterUpdateServicePasswordCounter) } } @@ -13493,16 +16344,19 @@ type mClientMockWaitForClickPipeState struct { callArgs []*ClientMockWaitForClickPipeStateParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockWaitForClickPipeStateExpectation specifies expectation struct of the Client.WaitForClickPipeState type ClientMockWaitForClickPipeStateExpectation struct { - mock *ClientMock - params *ClientMockWaitForClickPipeStateParams - paramPtrs *ClientMockWaitForClickPipeStateParamPtrs - results *ClientMockWaitForClickPipeStateResults - Counter uint64 + mock *ClientMock + params *ClientMockWaitForClickPipeStateParams + paramPtrs *ClientMockWaitForClickPipeStateParamPtrs + expectationOrigins ClientMockWaitForClickPipeStateExpectationOrigins + results *ClientMockWaitForClickPipeStateResults + returnOrigin string + Counter uint64 } // ClientMockWaitForClickPipeStateParams contains parameters of the Client.WaitForClickPipeState @@ -13529,6 +16383,16 @@ type ClientMockWaitForClickPipeStateResults struct { err error } +// ClientMockWaitForClickPipeStateOrigins contains origins of expectations of the Client.WaitForClickPipeState +type ClientMockWaitForClickPipeStateExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originClickPipeId string + originStateChecker string + originMaxWaitSeconds string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -13554,6 +16418,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) Expect(ctx cont } mmWaitForClickPipeState.defaultExpectation.params = &ClientMockWaitForClickPipeStateParams{ctx, serviceId, clickPipeId, stateChecker, maxWaitSeconds} + mmWaitForClickPipeState.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmWaitForClickPipeState.expectations { if minimock.Equal(e.params, mmWaitForClickPipeState.defaultExpectation.params) { mmWaitForClickPipeState.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmWaitForClickPipeState.defaultExpectation.params) @@ -13581,6 +16446,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) ExpectCtxParam1 mmWaitForClickPipeState.defaultExpectation.paramPtrs = &ClientMockWaitForClickPipeStateParamPtrs{} } mmWaitForClickPipeState.defaultExpectation.paramPtrs.ctx = &ctx + mmWaitForClickPipeState.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmWaitForClickPipeState } @@ -13603,6 +16469,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) ExpectServiceId mmWaitForClickPipeState.defaultExpectation.paramPtrs = &ClientMockWaitForClickPipeStateParamPtrs{} } mmWaitForClickPipeState.defaultExpectation.paramPtrs.serviceId = &serviceId + mmWaitForClickPipeState.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmWaitForClickPipeState } @@ -13625,6 +16492,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) ExpectClickPipe mmWaitForClickPipeState.defaultExpectation.paramPtrs = &ClientMockWaitForClickPipeStateParamPtrs{} } mmWaitForClickPipeState.defaultExpectation.paramPtrs.clickPipeId = &clickPipeId + mmWaitForClickPipeState.defaultExpectation.expectationOrigins.originClickPipeId = minimock.CallerInfo(1) return mmWaitForClickPipeState } @@ -13647,6 +16515,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) ExpectStateChec mmWaitForClickPipeState.defaultExpectation.paramPtrs = &ClientMockWaitForClickPipeStateParamPtrs{} } mmWaitForClickPipeState.defaultExpectation.paramPtrs.stateChecker = &stateChecker + mmWaitForClickPipeState.defaultExpectation.expectationOrigins.originStateChecker = minimock.CallerInfo(1) return mmWaitForClickPipeState } @@ -13669,6 +16538,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) ExpectMaxWaitSe mmWaitForClickPipeState.defaultExpectation.paramPtrs = &ClientMockWaitForClickPipeStateParamPtrs{} } mmWaitForClickPipeState.defaultExpectation.paramPtrs.maxWaitSeconds = &maxWaitSeconds + mmWaitForClickPipeState.defaultExpectation.expectationOrigins.originMaxWaitSeconds = minimock.CallerInfo(1) return mmWaitForClickPipeState } @@ -13694,6 +16564,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) Return(cp1 *Cli mmWaitForClickPipeState.defaultExpectation = &ClientMockWaitForClickPipeStateExpectation{mock: mmWaitForClickPipeState.mock} } mmWaitForClickPipeState.defaultExpectation.results = &ClientMockWaitForClickPipeStateResults{cp1, err} + mmWaitForClickPipeState.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmWaitForClickPipeState.mock } @@ -13708,6 +16579,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) Set(f func(ctx } mmWaitForClickPipeState.mock.funcWaitForClickPipeState = f + mmWaitForClickPipeState.mock.funcWaitForClickPipeStateOrigin = minimock.CallerInfo(1) return mmWaitForClickPipeState.mock } @@ -13719,8 +16591,9 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) When(ctx contex } expectation := &ClientMockWaitForClickPipeStateExpectation{ - mock: mmWaitForClickPipeState.mock, - params: &ClientMockWaitForClickPipeStateParams{ctx, serviceId, clickPipeId, stateChecker, maxWaitSeconds}, + mock: mmWaitForClickPipeState.mock, + params: &ClientMockWaitForClickPipeStateParams{ctx, serviceId, clickPipeId, stateChecker, maxWaitSeconds}, + expectationOrigins: ClientMockWaitForClickPipeStateExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmWaitForClickPipeState.expectations = append(mmWaitForClickPipeState.expectations, expectation) return expectation @@ -13738,6 +16611,7 @@ func (mmWaitForClickPipeState *mClientMockWaitForClickPipeState) Times(n uint64) mmWaitForClickPipeState.mock.t.Fatalf("Times of ClientMock.WaitForClickPipeState mock can not be zero") } mm_atomic.StoreUint64(&mmWaitForClickPipeState.expectedInvocations, n) + mmWaitForClickPipeState.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmWaitForClickPipeState } @@ -13757,6 +16631,8 @@ func (mmWaitForClickPipeState *ClientMock) WaitForClickPipeState(ctx context.Con mm_atomic.AddUint64(&mmWaitForClickPipeState.beforeWaitForClickPipeStateCounter, 1) defer mm_atomic.AddUint64(&mmWaitForClickPipeState.afterWaitForClickPipeStateCounter, 1) + mmWaitForClickPipeState.t.Helper() + if mmWaitForClickPipeState.inspectFuncWaitForClickPipeState != nil { mmWaitForClickPipeState.inspectFuncWaitForClickPipeState(ctx, serviceId, clickPipeId, stateChecker, maxWaitSeconds) } @@ -13785,27 +16661,33 @@ func (mmWaitForClickPipeState *ClientMock) WaitForClickPipeState(ctx context.Con if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForClickPipeState.WaitForClickPipeStateMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForClickPipeState.WaitForClickPipeStateMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.clickPipeId != nil && !minimock.Equal(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId) { - mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter clickPipeId, want: %#v, got: %#v%s\n", *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) + mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter clickPipeId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForClickPipeState.WaitForClickPipeStateMock.defaultExpectation.expectationOrigins.originClickPipeId, *mm_want_ptrs.clickPipeId, mm_got.clickPipeId, minimock.Diff(*mm_want_ptrs.clickPipeId, mm_got.clickPipeId)) } if mm_want_ptrs.stateChecker != nil && !minimock.Equal(*mm_want_ptrs.stateChecker, mm_got.stateChecker) { - mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter stateChecker, want: %#v, got: %#v%s\n", *mm_want_ptrs.stateChecker, mm_got.stateChecker, minimock.Diff(*mm_want_ptrs.stateChecker, mm_got.stateChecker)) + mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter stateChecker, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForClickPipeState.WaitForClickPipeStateMock.defaultExpectation.expectationOrigins.originStateChecker, *mm_want_ptrs.stateChecker, mm_got.stateChecker, minimock.Diff(*mm_want_ptrs.stateChecker, mm_got.stateChecker)) } if mm_want_ptrs.maxWaitSeconds != nil && !minimock.Equal(*mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds) { - mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter maxWaitSeconds, want: %#v, got: %#v%s\n", *mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds, minimock.Diff(*mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds)) + mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameter maxWaitSeconds, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForClickPipeState.WaitForClickPipeStateMock.defaultExpectation.expectationOrigins.originMaxWaitSeconds, *mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds, minimock.Diff(*mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmWaitForClickPipeState.t.Errorf("ClientMock.WaitForClickPipeState got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForClickPipeState.WaitForClickPipeStateMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmWaitForClickPipeState.WaitForClickPipeStateMock.defaultExpectation.results @@ -13865,7 +16747,7 @@ func (m *ClientMock) MinimockWaitForClickPipeStateDone() bool { func (m *ClientMock) MinimockWaitForClickPipeStateInspect() { for _, e := range m.WaitForClickPipeStateMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.WaitForClickPipeState with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.WaitForClickPipeState at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -13873,19 +16755,455 @@ func (m *ClientMock) MinimockWaitForClickPipeStateInspect() { // if default expectation was set then invocations count should be greater than zero if m.WaitForClickPipeStateMock.defaultExpectation != nil && afterWaitForClickPipeStateCounter < 1 { if m.WaitForClickPipeStateMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.WaitForClickPipeState") + m.t.Errorf("Expected call to ClientMock.WaitForClickPipeState at\n%s", m.WaitForClickPipeStateMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.WaitForClickPipeState with params: %#v", *m.WaitForClickPipeStateMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.WaitForClickPipeState at\n%s with params: %#v", m.WaitForClickPipeStateMock.defaultExpectation.expectationOrigins.origin, *m.WaitForClickPipeStateMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcWaitForClickPipeState != nil && afterWaitForClickPipeStateCounter < 1 { - m.t.Error("Expected call to ClientMock.WaitForClickPipeState") + m.t.Errorf("Expected call to ClientMock.WaitForClickPipeState at\n%s", m.funcWaitForClickPipeStateOrigin) } if !m.WaitForClickPipeStateMock.invocationsDone() && afterWaitForClickPipeStateCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.WaitForClickPipeState but found %d calls", - mm_atomic.LoadUint64(&m.WaitForClickPipeStateMock.expectedInvocations), afterWaitForClickPipeStateCounter) + m.t.Errorf("Expected %d calls to ClientMock.WaitForClickPipeState at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.WaitForClickPipeStateMock.expectedInvocations), m.WaitForClickPipeStateMock.expectedInvocationsOrigin, afterWaitForClickPipeStateCounter) + } +} + +type mClientMockWaitForReversePrivateEndpointState struct { + optional bool + mock *ClientMock + defaultExpectation *ClientMockWaitForReversePrivateEndpointStateExpectation + expectations []*ClientMockWaitForReversePrivateEndpointStateExpectation + + callArgs []*ClientMockWaitForReversePrivateEndpointStateParams + mutex sync.RWMutex + + expectedInvocations uint64 + expectedInvocationsOrigin string +} + +// ClientMockWaitForReversePrivateEndpointStateExpectation specifies expectation struct of the Client.WaitForReversePrivateEndpointState +type ClientMockWaitForReversePrivateEndpointStateExpectation struct { + mock *ClientMock + params *ClientMockWaitForReversePrivateEndpointStateParams + paramPtrs *ClientMockWaitForReversePrivateEndpointStateParamPtrs + expectationOrigins ClientMockWaitForReversePrivateEndpointStateExpectationOrigins + results *ClientMockWaitForReversePrivateEndpointStateResults + returnOrigin string + Counter uint64 +} + +// ClientMockWaitForReversePrivateEndpointStateParams contains parameters of the Client.WaitForReversePrivateEndpointState +type ClientMockWaitForReversePrivateEndpointStateParams struct { + ctx context.Context + serviceId string + reversePrivateEndpointId string + stateChecker func(string) bool + maxWaitSeconds uint64 +} + +// ClientMockWaitForReversePrivateEndpointStateParamPtrs contains pointers to parameters of the Client.WaitForReversePrivateEndpointState +type ClientMockWaitForReversePrivateEndpointStateParamPtrs struct { + ctx *context.Context + serviceId *string + reversePrivateEndpointId *string + stateChecker *func(string) bool + maxWaitSeconds *uint64 +} + +// ClientMockWaitForReversePrivateEndpointStateResults contains results of the Client.WaitForReversePrivateEndpointState +type ClientMockWaitForReversePrivateEndpointStateResults struct { + rp1 *ReversePrivateEndpoint + err error +} + +// ClientMockWaitForReversePrivateEndpointStateOrigins contains origins of expectations of the Client.WaitForReversePrivateEndpointState +type ClientMockWaitForReversePrivateEndpointStateExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originReversePrivateEndpointId string + originStateChecker string + originMaxWaitSeconds string +} + +// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning +// the test will fail minimock's automatic final call check if the mocked method was not called at least once. +// Optional() makes method check to work in '0 or more' mode. +// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to +// catch the problems when the expected method call is totally skipped during test run. +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) Optional() *mClientMockWaitForReversePrivateEndpointState { + mmWaitForReversePrivateEndpointState.optional = true + return mmWaitForReversePrivateEndpointState +} + +// Expect sets up expected params for Client.WaitForReversePrivateEndpointState +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) Expect(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64) *mClientMockWaitForReversePrivateEndpointState { + if mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Set") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation = &ClientMockWaitForReversePrivateEndpointStateExpectation{} + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by ExpectParams functions") + } + + mmWaitForReversePrivateEndpointState.defaultExpectation.params = &ClientMockWaitForReversePrivateEndpointStateParams{ctx, serviceId, reversePrivateEndpointId, stateChecker, maxWaitSeconds} + mmWaitForReversePrivateEndpointState.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) + for _, e := range mmWaitForReversePrivateEndpointState.expectations { + if minimock.Equal(e.params, mmWaitForReversePrivateEndpointState.defaultExpectation.params) { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmWaitForReversePrivateEndpointState.defaultExpectation.params) + } + } + + return mmWaitForReversePrivateEndpointState +} + +// ExpectCtxParam1 sets up expected param ctx for Client.WaitForReversePrivateEndpointState +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) ExpectCtxParam1(ctx context.Context) *mClientMockWaitForReversePrivateEndpointState { + if mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Set") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation = &ClientMockWaitForReversePrivateEndpointStateExpectation{} + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.params != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Expect") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs = &ClientMockWaitForReversePrivateEndpointStateParamPtrs{} + } + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs.ctx = &ctx + mmWaitForReversePrivateEndpointState.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) + + return mmWaitForReversePrivateEndpointState +} + +// ExpectServiceIdParam2 sets up expected param serviceId for Client.WaitForReversePrivateEndpointState +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) ExpectServiceIdParam2(serviceId string) *mClientMockWaitForReversePrivateEndpointState { + if mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Set") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation = &ClientMockWaitForReversePrivateEndpointStateExpectation{} + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.params != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Expect") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs = &ClientMockWaitForReversePrivateEndpointStateParamPtrs{} + } + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs.serviceId = &serviceId + mmWaitForReversePrivateEndpointState.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) + + return mmWaitForReversePrivateEndpointState +} + +// ExpectReversePrivateEndpointIdParam3 sets up expected param reversePrivateEndpointId for Client.WaitForReversePrivateEndpointState +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) ExpectReversePrivateEndpointIdParam3(reversePrivateEndpointId string) *mClientMockWaitForReversePrivateEndpointState { + if mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Set") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation = &ClientMockWaitForReversePrivateEndpointStateExpectation{} + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.params != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Expect") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs = &ClientMockWaitForReversePrivateEndpointStateParamPtrs{} + } + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs.reversePrivateEndpointId = &reversePrivateEndpointId + mmWaitForReversePrivateEndpointState.defaultExpectation.expectationOrigins.originReversePrivateEndpointId = minimock.CallerInfo(1) + + return mmWaitForReversePrivateEndpointState +} + +// ExpectStateCheckerParam4 sets up expected param stateChecker for Client.WaitForReversePrivateEndpointState +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) ExpectStateCheckerParam4(stateChecker func(string) bool) *mClientMockWaitForReversePrivateEndpointState { + if mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Set") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation = &ClientMockWaitForReversePrivateEndpointStateExpectation{} + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.params != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Expect") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs = &ClientMockWaitForReversePrivateEndpointStateParamPtrs{} + } + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs.stateChecker = &stateChecker + mmWaitForReversePrivateEndpointState.defaultExpectation.expectationOrigins.originStateChecker = minimock.CallerInfo(1) + + return mmWaitForReversePrivateEndpointState +} + +// ExpectMaxWaitSecondsParam5 sets up expected param maxWaitSeconds for Client.WaitForReversePrivateEndpointState +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) ExpectMaxWaitSecondsParam5(maxWaitSeconds uint64) *mClientMockWaitForReversePrivateEndpointState { + if mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Set") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation = &ClientMockWaitForReversePrivateEndpointStateExpectation{} + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.params != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Expect") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs = &ClientMockWaitForReversePrivateEndpointStateParamPtrs{} + } + mmWaitForReversePrivateEndpointState.defaultExpectation.paramPtrs.maxWaitSeconds = &maxWaitSeconds + mmWaitForReversePrivateEndpointState.defaultExpectation.expectationOrigins.originMaxWaitSeconds = minimock.CallerInfo(1) + + return mmWaitForReversePrivateEndpointState +} + +// Inspect accepts an inspector function that has same arguments as the Client.WaitForReversePrivateEndpointState +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) Inspect(f func(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64)) *mClientMockWaitForReversePrivateEndpointState { + if mmWaitForReversePrivateEndpointState.mock.inspectFuncWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("Inspect function is already set for ClientMock.WaitForReversePrivateEndpointState") + } + + mmWaitForReversePrivateEndpointState.mock.inspectFuncWaitForReversePrivateEndpointState = f + + return mmWaitForReversePrivateEndpointState +} + +// Return sets up results that will be returned by Client.WaitForReversePrivateEndpointState +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) Return(rp1 *ReversePrivateEndpoint, err error) *ClientMock { + if mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Set") + } + + if mmWaitForReversePrivateEndpointState.defaultExpectation == nil { + mmWaitForReversePrivateEndpointState.defaultExpectation = &ClientMockWaitForReversePrivateEndpointStateExpectation{mock: mmWaitForReversePrivateEndpointState.mock} + } + mmWaitForReversePrivateEndpointState.defaultExpectation.results = &ClientMockWaitForReversePrivateEndpointStateResults{rp1, err} + mmWaitForReversePrivateEndpointState.defaultExpectation.returnOrigin = minimock.CallerInfo(1) + return mmWaitForReversePrivateEndpointState.mock +} + +// Set uses given function f to mock the Client.WaitForReversePrivateEndpointState method +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) Set(f func(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64) (rp1 *ReversePrivateEndpoint, err error)) *ClientMock { + if mmWaitForReversePrivateEndpointState.defaultExpectation != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("Default expectation is already set for the Client.WaitForReversePrivateEndpointState method") + } + + if len(mmWaitForReversePrivateEndpointState.expectations) > 0 { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("Some expectations are already set for the Client.WaitForReversePrivateEndpointState method") + } + + mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState = f + mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointStateOrigin = minimock.CallerInfo(1) + return mmWaitForReversePrivateEndpointState.mock +} + +// When sets expectation for the Client.WaitForReversePrivateEndpointState which will trigger the result defined by the following +// Then helper +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) When(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64) *ClientMockWaitForReversePrivateEndpointStateExpectation { + if mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("ClientMock.WaitForReversePrivateEndpointState mock is already set by Set") + } + + expectation := &ClientMockWaitForReversePrivateEndpointStateExpectation{ + mock: mmWaitForReversePrivateEndpointState.mock, + params: &ClientMockWaitForReversePrivateEndpointStateParams{ctx, serviceId, reversePrivateEndpointId, stateChecker, maxWaitSeconds}, + expectationOrigins: ClientMockWaitForReversePrivateEndpointStateExpectationOrigins{origin: minimock.CallerInfo(1)}, + } + mmWaitForReversePrivateEndpointState.expectations = append(mmWaitForReversePrivateEndpointState.expectations, expectation) + return expectation +} + +// Then sets up Client.WaitForReversePrivateEndpointState return parameters for the expectation previously defined by the When method +func (e *ClientMockWaitForReversePrivateEndpointStateExpectation) Then(rp1 *ReversePrivateEndpoint, err error) *ClientMock { + e.results = &ClientMockWaitForReversePrivateEndpointStateResults{rp1, err} + return e.mock +} + +// Times sets number of times Client.WaitForReversePrivateEndpointState should be invoked +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) Times(n uint64) *mClientMockWaitForReversePrivateEndpointState { + if n == 0 { + mmWaitForReversePrivateEndpointState.mock.t.Fatalf("Times of ClientMock.WaitForReversePrivateEndpointState mock can not be zero") + } + mm_atomic.StoreUint64(&mmWaitForReversePrivateEndpointState.expectedInvocations, n) + mmWaitForReversePrivateEndpointState.expectedInvocationsOrigin = minimock.CallerInfo(1) + return mmWaitForReversePrivateEndpointState +} + +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) invocationsDone() bool { + if len(mmWaitForReversePrivateEndpointState.expectations) == 0 && mmWaitForReversePrivateEndpointState.defaultExpectation == nil && mmWaitForReversePrivateEndpointState.mock.funcWaitForReversePrivateEndpointState == nil { + return true + } + + totalInvocations := mm_atomic.LoadUint64(&mmWaitForReversePrivateEndpointState.mock.afterWaitForReversePrivateEndpointStateCounter) + expectedInvocations := mm_atomic.LoadUint64(&mmWaitForReversePrivateEndpointState.expectedInvocations) + + return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations) +} + +// WaitForReversePrivateEndpointState implements Client +func (mmWaitForReversePrivateEndpointState *ClientMock) WaitForReversePrivateEndpointState(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64) (rp1 *ReversePrivateEndpoint, err error) { + mm_atomic.AddUint64(&mmWaitForReversePrivateEndpointState.beforeWaitForReversePrivateEndpointStateCounter, 1) + defer mm_atomic.AddUint64(&mmWaitForReversePrivateEndpointState.afterWaitForReversePrivateEndpointStateCounter, 1) + + mmWaitForReversePrivateEndpointState.t.Helper() + + if mmWaitForReversePrivateEndpointState.inspectFuncWaitForReversePrivateEndpointState != nil { + mmWaitForReversePrivateEndpointState.inspectFuncWaitForReversePrivateEndpointState(ctx, serviceId, reversePrivateEndpointId, stateChecker, maxWaitSeconds) + } + + mm_params := ClientMockWaitForReversePrivateEndpointStateParams{ctx, serviceId, reversePrivateEndpointId, stateChecker, maxWaitSeconds} + + // Record call args + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.mutex.Lock() + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.callArgs = append(mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.callArgs, &mm_params) + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.mutex.Unlock() + + for _, e := range mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.rp1, e.results.err + } + } + + if mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.Counter, 1) + mm_want := mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.params + mm_want_ptrs := mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.paramPtrs + + mm_got := ClientMockWaitForReversePrivateEndpointStateParams{ctx, serviceId, reversePrivateEndpointId, stateChecker, maxWaitSeconds} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmWaitForReversePrivateEndpointState.t.Errorf("ClientMock.WaitForReversePrivateEndpointState got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { + mmWaitForReversePrivateEndpointState.t.Errorf("ClientMock.WaitForReversePrivateEndpointState got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + } + + if mm_want_ptrs.reversePrivateEndpointId != nil && !minimock.Equal(*mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId) { + mmWaitForReversePrivateEndpointState.t.Errorf("ClientMock.WaitForReversePrivateEndpointState got unexpected parameter reversePrivateEndpointId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.expectationOrigins.originReversePrivateEndpointId, *mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId, minimock.Diff(*mm_want_ptrs.reversePrivateEndpointId, mm_got.reversePrivateEndpointId)) + } + + if mm_want_ptrs.stateChecker != nil && !minimock.Equal(*mm_want_ptrs.stateChecker, mm_got.stateChecker) { + mmWaitForReversePrivateEndpointState.t.Errorf("ClientMock.WaitForReversePrivateEndpointState got unexpected parameter stateChecker, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.expectationOrigins.originStateChecker, *mm_want_ptrs.stateChecker, mm_got.stateChecker, minimock.Diff(*mm_want_ptrs.stateChecker, mm_got.stateChecker)) + } + + if mm_want_ptrs.maxWaitSeconds != nil && !minimock.Equal(*mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds) { + mmWaitForReversePrivateEndpointState.t.Errorf("ClientMock.WaitForReversePrivateEndpointState got unexpected parameter maxWaitSeconds, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.expectationOrigins.originMaxWaitSeconds, *mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds, minimock.Diff(*mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmWaitForReversePrivateEndpointState.t.Errorf("ClientMock.WaitForReversePrivateEndpointState got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmWaitForReversePrivateEndpointState.WaitForReversePrivateEndpointStateMock.defaultExpectation.results + if mm_results == nil { + mmWaitForReversePrivateEndpointState.t.Fatal("No results are set for the ClientMock.WaitForReversePrivateEndpointState") + } + return (*mm_results).rp1, (*mm_results).err + } + if mmWaitForReversePrivateEndpointState.funcWaitForReversePrivateEndpointState != nil { + return mmWaitForReversePrivateEndpointState.funcWaitForReversePrivateEndpointState(ctx, serviceId, reversePrivateEndpointId, stateChecker, maxWaitSeconds) + } + mmWaitForReversePrivateEndpointState.t.Fatalf("Unexpected call to ClientMock.WaitForReversePrivateEndpointState. %v %v %v %v %v", ctx, serviceId, reversePrivateEndpointId, stateChecker, maxWaitSeconds) + return +} + +// WaitForReversePrivateEndpointStateAfterCounter returns a count of finished ClientMock.WaitForReversePrivateEndpointState invocations +func (mmWaitForReversePrivateEndpointState *ClientMock) WaitForReversePrivateEndpointStateAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmWaitForReversePrivateEndpointState.afterWaitForReversePrivateEndpointStateCounter) +} + +// WaitForReversePrivateEndpointStateBeforeCounter returns a count of ClientMock.WaitForReversePrivateEndpointState invocations +func (mmWaitForReversePrivateEndpointState *ClientMock) WaitForReversePrivateEndpointStateBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmWaitForReversePrivateEndpointState.beforeWaitForReversePrivateEndpointStateCounter) +} + +// Calls returns a list of arguments used in each call to ClientMock.WaitForReversePrivateEndpointState. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmWaitForReversePrivateEndpointState *mClientMockWaitForReversePrivateEndpointState) Calls() []*ClientMockWaitForReversePrivateEndpointStateParams { + mmWaitForReversePrivateEndpointState.mutex.RLock() + + argCopy := make([]*ClientMockWaitForReversePrivateEndpointStateParams, len(mmWaitForReversePrivateEndpointState.callArgs)) + copy(argCopy, mmWaitForReversePrivateEndpointState.callArgs) + + mmWaitForReversePrivateEndpointState.mutex.RUnlock() + + return argCopy +} + +// MinimockWaitForReversePrivateEndpointStateDone returns true if the count of the WaitForReversePrivateEndpointState invocations corresponds +// the number of defined expectations +func (m *ClientMock) MinimockWaitForReversePrivateEndpointStateDone() bool { + if m.WaitForReversePrivateEndpointStateMock.optional { + // Optional methods provide '0 or more' call count restriction. + return true + } + + for _, e := range m.WaitForReversePrivateEndpointStateMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + return m.WaitForReversePrivateEndpointStateMock.invocationsDone() +} + +// MinimockWaitForReversePrivateEndpointStateInspect logs each unmet expectation +func (m *ClientMock) MinimockWaitForReversePrivateEndpointStateInspect() { + for _, e := range m.WaitForReversePrivateEndpointStateMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to ClientMock.WaitForReversePrivateEndpointState at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) + } + } + + afterWaitForReversePrivateEndpointStateCounter := mm_atomic.LoadUint64(&m.afterWaitForReversePrivateEndpointStateCounter) + // if default expectation was set then invocations count should be greater than zero + if m.WaitForReversePrivateEndpointStateMock.defaultExpectation != nil && afterWaitForReversePrivateEndpointStateCounter < 1 { + if m.WaitForReversePrivateEndpointStateMock.defaultExpectation.params == nil { + m.t.Errorf("Expected call to ClientMock.WaitForReversePrivateEndpointState at\n%s", m.WaitForReversePrivateEndpointStateMock.defaultExpectation.returnOrigin) + } else { + m.t.Errorf("Expected call to ClientMock.WaitForReversePrivateEndpointState at\n%s with params: %#v", m.WaitForReversePrivateEndpointStateMock.defaultExpectation.expectationOrigins.origin, *m.WaitForReversePrivateEndpointStateMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcWaitForReversePrivateEndpointState != nil && afterWaitForReversePrivateEndpointStateCounter < 1 { + m.t.Errorf("Expected call to ClientMock.WaitForReversePrivateEndpointState at\n%s", m.funcWaitForReversePrivateEndpointStateOrigin) + } + + if !m.WaitForReversePrivateEndpointStateMock.invocationsDone() && afterWaitForReversePrivateEndpointStateCounter > 0 { + m.t.Errorf("Expected %d calls to ClientMock.WaitForReversePrivateEndpointState at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.WaitForReversePrivateEndpointStateMock.expectedInvocations), m.WaitForReversePrivateEndpointStateMock.expectedInvocationsOrigin, afterWaitForReversePrivateEndpointStateCounter) } } @@ -13898,16 +17216,19 @@ type mClientMockWaitForServiceState struct { callArgs []*ClientMockWaitForServiceStateParams mutex sync.RWMutex - expectedInvocations uint64 + expectedInvocations uint64 + expectedInvocationsOrigin string } // ClientMockWaitForServiceStateExpectation specifies expectation struct of the Client.WaitForServiceState type ClientMockWaitForServiceStateExpectation struct { - mock *ClientMock - params *ClientMockWaitForServiceStateParams - paramPtrs *ClientMockWaitForServiceStateParamPtrs - results *ClientMockWaitForServiceStateResults - Counter uint64 + mock *ClientMock + params *ClientMockWaitForServiceStateParams + paramPtrs *ClientMockWaitForServiceStateParamPtrs + expectationOrigins ClientMockWaitForServiceStateExpectationOrigins + results *ClientMockWaitForServiceStateResults + returnOrigin string + Counter uint64 } // ClientMockWaitForServiceStateParams contains parameters of the Client.WaitForServiceState @@ -13931,6 +17252,15 @@ type ClientMockWaitForServiceStateResults struct { err error } +// ClientMockWaitForServiceStateOrigins contains origins of expectations of the Client.WaitForServiceState +type ClientMockWaitForServiceStateExpectationOrigins struct { + origin string + originCtx string + originServiceId string + originStateChecker string + originMaxWaitSeconds string +} + // Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning // the test will fail minimock's automatic final call check if the mocked method was not called at least once. // Optional() makes method check to work in '0 or more' mode. @@ -13956,6 +17286,7 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) Expect(ctx context. } mmWaitForServiceState.defaultExpectation.params = &ClientMockWaitForServiceStateParams{ctx, serviceId, stateChecker, maxWaitSeconds} + mmWaitForServiceState.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1) for _, e := range mmWaitForServiceState.expectations { if minimock.Equal(e.params, mmWaitForServiceState.defaultExpectation.params) { mmWaitForServiceState.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmWaitForServiceState.defaultExpectation.params) @@ -13983,6 +17314,7 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) ExpectCtxParam1(ctx mmWaitForServiceState.defaultExpectation.paramPtrs = &ClientMockWaitForServiceStateParamPtrs{} } mmWaitForServiceState.defaultExpectation.paramPtrs.ctx = &ctx + mmWaitForServiceState.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1) return mmWaitForServiceState } @@ -14005,6 +17337,7 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) ExpectServiceIdPara mmWaitForServiceState.defaultExpectation.paramPtrs = &ClientMockWaitForServiceStateParamPtrs{} } mmWaitForServiceState.defaultExpectation.paramPtrs.serviceId = &serviceId + mmWaitForServiceState.defaultExpectation.expectationOrigins.originServiceId = minimock.CallerInfo(1) return mmWaitForServiceState } @@ -14027,6 +17360,7 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) ExpectStateCheckerP mmWaitForServiceState.defaultExpectation.paramPtrs = &ClientMockWaitForServiceStateParamPtrs{} } mmWaitForServiceState.defaultExpectation.paramPtrs.stateChecker = &stateChecker + mmWaitForServiceState.defaultExpectation.expectationOrigins.originStateChecker = minimock.CallerInfo(1) return mmWaitForServiceState } @@ -14049,6 +17383,7 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) ExpectMaxWaitSecond mmWaitForServiceState.defaultExpectation.paramPtrs = &ClientMockWaitForServiceStateParamPtrs{} } mmWaitForServiceState.defaultExpectation.paramPtrs.maxWaitSeconds = &maxWaitSeconds + mmWaitForServiceState.defaultExpectation.expectationOrigins.originMaxWaitSeconds = minimock.CallerInfo(1) return mmWaitForServiceState } @@ -14074,6 +17409,7 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) Return(err error) * mmWaitForServiceState.defaultExpectation = &ClientMockWaitForServiceStateExpectation{mock: mmWaitForServiceState.mock} } mmWaitForServiceState.defaultExpectation.results = &ClientMockWaitForServiceStateResults{err} + mmWaitForServiceState.defaultExpectation.returnOrigin = minimock.CallerInfo(1) return mmWaitForServiceState.mock } @@ -14088,6 +17424,7 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) Set(f func(ctx cont } mmWaitForServiceState.mock.funcWaitForServiceState = f + mmWaitForServiceState.mock.funcWaitForServiceStateOrigin = minimock.CallerInfo(1) return mmWaitForServiceState.mock } @@ -14099,8 +17436,9 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) When(ctx context.Co } expectation := &ClientMockWaitForServiceStateExpectation{ - mock: mmWaitForServiceState.mock, - params: &ClientMockWaitForServiceStateParams{ctx, serviceId, stateChecker, maxWaitSeconds}, + mock: mmWaitForServiceState.mock, + params: &ClientMockWaitForServiceStateParams{ctx, serviceId, stateChecker, maxWaitSeconds}, + expectationOrigins: ClientMockWaitForServiceStateExpectationOrigins{origin: minimock.CallerInfo(1)}, } mmWaitForServiceState.expectations = append(mmWaitForServiceState.expectations, expectation) return expectation @@ -14118,6 +17456,7 @@ func (mmWaitForServiceState *mClientMockWaitForServiceState) Times(n uint64) *mC mmWaitForServiceState.mock.t.Fatalf("Times of ClientMock.WaitForServiceState mock can not be zero") } mm_atomic.StoreUint64(&mmWaitForServiceState.expectedInvocations, n) + mmWaitForServiceState.expectedInvocationsOrigin = minimock.CallerInfo(1) return mmWaitForServiceState } @@ -14137,6 +17476,8 @@ func (mmWaitForServiceState *ClientMock) WaitForServiceState(ctx context.Context mm_atomic.AddUint64(&mmWaitForServiceState.beforeWaitForServiceStateCounter, 1) defer mm_atomic.AddUint64(&mmWaitForServiceState.afterWaitForServiceStateCounter, 1) + mmWaitForServiceState.t.Helper() + if mmWaitForServiceState.inspectFuncWaitForServiceState != nil { mmWaitForServiceState.inspectFuncWaitForServiceState(ctx, serviceId, stateChecker, maxWaitSeconds) } @@ -14165,23 +17506,28 @@ func (mmWaitForServiceState *ClientMock) WaitForServiceState(ctx context.Context if mm_want_ptrs != nil { if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { - mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForServiceState.WaitForServiceStateMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) } if mm_want_ptrs.serviceId != nil && !minimock.Equal(*mm_want_ptrs.serviceId, mm_got.serviceId) { - mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameter serviceId, want: %#v, got: %#v%s\n", *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) + mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameter serviceId, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForServiceState.WaitForServiceStateMock.defaultExpectation.expectationOrigins.originServiceId, *mm_want_ptrs.serviceId, mm_got.serviceId, minimock.Diff(*mm_want_ptrs.serviceId, mm_got.serviceId)) } if mm_want_ptrs.stateChecker != nil && !minimock.Equal(*mm_want_ptrs.stateChecker, mm_got.stateChecker) { - mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameter stateChecker, want: %#v, got: %#v%s\n", *mm_want_ptrs.stateChecker, mm_got.stateChecker, minimock.Diff(*mm_want_ptrs.stateChecker, mm_got.stateChecker)) + mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameter stateChecker, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForServiceState.WaitForServiceStateMock.defaultExpectation.expectationOrigins.originStateChecker, *mm_want_ptrs.stateChecker, mm_got.stateChecker, minimock.Diff(*mm_want_ptrs.stateChecker, mm_got.stateChecker)) } if mm_want_ptrs.maxWaitSeconds != nil && !minimock.Equal(*mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds) { - mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameter maxWaitSeconds, want: %#v, got: %#v%s\n", *mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds, minimock.Diff(*mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds)) + mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameter maxWaitSeconds, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForServiceState.WaitForServiceStateMock.defaultExpectation.expectationOrigins.originMaxWaitSeconds, *mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds, minimock.Diff(*mm_want_ptrs.maxWaitSeconds, mm_got.maxWaitSeconds)) } } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { - mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + mmWaitForServiceState.t.Errorf("ClientMock.WaitForServiceState got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n", + mmWaitForServiceState.WaitForServiceStateMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } mm_results := mmWaitForServiceState.WaitForServiceStateMock.defaultExpectation.results @@ -14241,7 +17587,7 @@ func (m *ClientMock) MinimockWaitForServiceStateDone() bool { func (m *ClientMock) MinimockWaitForServiceStateInspect() { for _, e := range m.WaitForServiceStateMock.expectations { if mm_atomic.LoadUint64(&e.Counter) < 1 { - m.t.Errorf("Expected call to ClientMock.WaitForServiceState with params: %#v", *e.params) + m.t.Errorf("Expected call to ClientMock.WaitForServiceState at\n%s with params: %#v", e.expectationOrigins.origin, *e.params) } } @@ -14249,19 +17595,19 @@ func (m *ClientMock) MinimockWaitForServiceStateInspect() { // if default expectation was set then invocations count should be greater than zero if m.WaitForServiceStateMock.defaultExpectation != nil && afterWaitForServiceStateCounter < 1 { if m.WaitForServiceStateMock.defaultExpectation.params == nil { - m.t.Error("Expected call to ClientMock.WaitForServiceState") + m.t.Errorf("Expected call to ClientMock.WaitForServiceState at\n%s", m.WaitForServiceStateMock.defaultExpectation.returnOrigin) } else { - m.t.Errorf("Expected call to ClientMock.WaitForServiceState with params: %#v", *m.WaitForServiceStateMock.defaultExpectation.params) + m.t.Errorf("Expected call to ClientMock.WaitForServiceState at\n%s with params: %#v", m.WaitForServiceStateMock.defaultExpectation.expectationOrigins.origin, *m.WaitForServiceStateMock.defaultExpectation.params) } } // if func was set then invocations count should be greater than zero if m.funcWaitForServiceState != nil && afterWaitForServiceStateCounter < 1 { - m.t.Error("Expected call to ClientMock.WaitForServiceState") + m.t.Errorf("Expected call to ClientMock.WaitForServiceState at\n%s", m.funcWaitForServiceStateOrigin) } if !m.WaitForServiceStateMock.invocationsDone() && afterWaitForServiceStateCounter > 0 { - m.t.Errorf("Expected %d calls to ClientMock.WaitForServiceState but found %d calls", - mm_atomic.LoadUint64(&m.WaitForServiceStateMock.expectedInvocations), afterWaitForServiceStateCounter) + m.t.Errorf("Expected %d calls to ClientMock.WaitForServiceState at\n%s but found %d calls", + mm_atomic.LoadUint64(&m.WaitForServiceStateMock.expectedInvocations), m.WaitForServiceStateMock.expectedInvocationsOrigin, afterWaitForServiceStateCounter) } } @@ -14277,6 +17623,8 @@ func (m *ClientMock) MinimockFinish() { m.MinimockCreateQueryEndpointInspect() + m.MinimockCreateReversePrivateEndpointInspect() + m.MinimockCreateRoleInspect() m.MinimockCreateServiceInspect() @@ -14289,6 +17637,8 @@ func (m *ClientMock) MinimockFinish() { m.MinimockDeleteQueryEndpointInspect() + m.MinimockDeleteReversePrivateEndpointInspect() + m.MinimockDeleteRoleInspect() m.MinimockDeleteServiceInspect() @@ -14313,6 +17663,10 @@ func (m *ClientMock) MinimockFinish() { m.MinimockGetQueryEndpointInspect() + m.MinimockGetReversePrivateEndpointInspect() + + m.MinimockGetReversePrivateEndpointPathInspect() + m.MinimockGetRoleInspect() m.MinimockGetServiceInspect() @@ -14323,6 +17677,8 @@ func (m *ClientMock) MinimockFinish() { m.MinimockGrantRoleInspect() + m.MinimockListReversePrivateEndpointsInspect() + m.MinimockRevokeGrantPrivilegeInspect() m.MinimockRevokeGrantRoleInspect() @@ -14345,6 +17701,8 @@ func (m *ClientMock) MinimockFinish() { m.MinimockWaitForClickPipeStateInspect() + m.MinimockWaitForReversePrivateEndpointStateInspect() + m.MinimockWaitForServiceStateInspect() } }) @@ -14373,12 +17731,14 @@ func (m *ClientMock) minimockDone() bool { m.MinimockCreateClickPipeDone() && m.MinimockCreateDatabaseDone() && m.MinimockCreateQueryEndpointDone() && + m.MinimockCreateReversePrivateEndpointDone() && m.MinimockCreateRoleDone() && m.MinimockCreateServiceDone() && m.MinimockCreateUserDone() && m.MinimockDeleteClickPipeDone() && m.MinimockDeleteDatabaseDone() && m.MinimockDeleteQueryEndpointDone() && + m.MinimockDeleteReversePrivateEndpointDone() && m.MinimockDeleteRoleDone() && m.MinimockDeleteServiceDone() && m.MinimockDeleteUserDone() && @@ -14391,11 +17751,14 @@ func (m *ClientMock) minimockDone() bool { m.MinimockGetOrgPrivateEndpointConfigDone() && m.MinimockGetOrganizationPrivateEndpointsDone() && m.MinimockGetQueryEndpointDone() && + m.MinimockGetReversePrivateEndpointDone() && + m.MinimockGetReversePrivateEndpointPathDone() && m.MinimockGetRoleDone() && m.MinimockGetServiceDone() && m.MinimockGetUserDone() && m.MinimockGrantPrivilegeDone() && m.MinimockGrantRoleDone() && + m.MinimockListReversePrivateEndpointsDone() && m.MinimockRevokeGrantPrivilegeDone() && m.MinimockRevokeGrantRoleDone() && m.MinimockScalingClickPipeDone() && @@ -14407,5 +17770,6 @@ func (m *ClientMock) minimockDone() bool { m.MinimockUpdateServiceDone() && m.MinimockUpdateServicePasswordDone() && m.MinimockWaitForClickPipeStateDone() && + m.MinimockWaitForReversePrivateEndpointStateDone() && m.MinimockWaitForServiceStateDone() } diff --git a/pkg/internal/api/interface.go b/pkg/internal/api/interface.go index 718e4b56..35e8227d 100644 --- a/pkg/internal/api/interface.go +++ b/pkg/internal/api/interface.go @@ -32,6 +32,13 @@ type Client interface { ChangeClickPipeState(ctx context.Context, serviceId string, clickPipeId string, command string) (*ClickPipe, error) DeleteClickPipe(ctx context.Context, serviceId string, clickPipeId string) error + GetReversePrivateEndpointPath(serviceId, reversePrivateEndpointId string) string + ListReversePrivateEndpoints(ctx context.Context, serviceId string) ([]*ReversePrivateEndpoint, error) + GetReversePrivateEndpoint(ctx context.Context, serviceId, reversePrivateEndpointId string) (*ReversePrivateEndpoint, error) + CreateReversePrivateEndpoint(ctx context.Context, serviceId string, request CreateReversePrivateEndpoint) (*ReversePrivateEndpoint, error) + DeleteReversePrivateEndpoint(ctx context.Context, serviceId, reversePrivateEndpointId string) error + WaitForReversePrivateEndpointState(ctx context.Context, serviceId string, reversePrivateEndpointId string, stateChecker func(string) bool, maxWaitSeconds uint64) (*ReversePrivateEndpoint, error) + CreateUser(ctx context.Context, serviceId string, user User) (*User, error) GetUser(ctx context.Context, serviceID string, name string) (*User, error) DeleteUser(ctx context.Context, serviceID string, name string) error diff --git a/pkg/resource/clickpipe.go b/pkg/resource/clickpipe.go index 86ff49d4..8055b196 100644 --- a/pkg/resource/clickpipe.go +++ b/pkg/resource/clickpipe.go @@ -37,8 +37,6 @@ var ( const clickPipeResourceDescription = ` This experimental resource allows you to create and manage ClickPipes data ingestion in ClickHouse Cloud. -Feature needs to be enabled on your account. Please contact ClickHouse Cloud support for more information. - **Resource is early access and may change in future releases. Feature coverage might not fully cover all ClickPipe capabilities.** Known limitations: @@ -299,6 +297,14 @@ func (c *ClickPipeResource) Schema(_ context.Context, _ resource.SchemaRequest, MarkdownDescription: "PEM encoded CA certificates to validate the broker's certificate.", Optional: true, }, + "reverse_private_endpoint_ids": schema.ListAttribute{ + MarkdownDescription: "The list of reverse private endpoint IDs for the Kafka source. (comma separated)", + Optional: true, + ElementType: types.StringType, + PlanModifiers: []planmodifier.List{ + listplanmodifier.RequiresReplace(), + }, + }, }, }, "object_storage": schema.SingleNestedAttribute{ @@ -778,6 +784,12 @@ func (c *ClickPipeResource) extractSourceFromPlan(ctx context.Context, diagnosti Timestamp: timestamp, } } + + if !kafkaModel.ReversePrivateEndpointIDs.IsNull() { + reversePrivateEndpointIDs := make([]string, len(kafkaModel.ReversePrivateEndpointIDs.Elements())) + diagnostics.Append(kafkaModel.ReversePrivateEndpointIDs.ElementsAs(ctx, &reversePrivateEndpointIDs, false)...) + source.Kafka.ReversePrivateEndpointIDs = reversePrivateEndpointIDs + } } else if !sourceModel.ObjectStorage.IsNull() { objectStorageModel := models.ClickPipeObjectStorageSourceModel{} @@ -937,6 +949,16 @@ func (c *ClickPipeResource) syncClickPipeState(ctx context.Context, state *model kafkaModel.Offset = types.ObjectNull(models.ClickPipeKafkaOffsetModel{}.ObjectType().AttrTypes) } + if clickPipe.Source.Kafka.ReversePrivateEndpointIDs != nil { + reversePrivateEndpointIDs := make([]attr.Value, len(clickPipe.Source.Kafka.ReversePrivateEndpointIDs)) + for i, id := range clickPipe.Source.Kafka.ReversePrivateEndpointIDs { + reversePrivateEndpointIDs[i] = types.StringValue(id) + } + kafkaModel.ReversePrivateEndpointIDs, _ = types.ListValue(types.StringType, reversePrivateEndpointIDs) + } else { + kafkaModel.ReversePrivateEndpointIDs = types.ListNull(types.StringType) + } + sourceModel.Kafka = kafkaModel.ObjectValue() } else { sourceModel.Kafka = types.ObjectNull(models.ClickPipeKafkaSourceModel{}.ObjectType().AttrTypes) diff --git a/pkg/resource/clickpipe_reverse_private_endpoint.go b/pkg/resource/clickpipe_reverse_private_endpoint.go new file mode 100644 index 00000000..c85d988d --- /dev/null +++ b/pkg/resource/clickpipe_reverse_private_endpoint.go @@ -0,0 +1,448 @@ +//go:build alpha + +package resource + +import ( + "context" + "fmt" + "strings" + "time" + + "github.com/ClickHouse/terraform-provider-clickhouse/pkg/internal/api" + "github.com/ClickHouse/terraform-provider-clickhouse/pkg/resource/models" + "github.com/cenkalti/backoff/v4" + "github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator" + "github.com/hashicorp/terraform-plugin-framework/path" + "github.com/hashicorp/terraform-plugin-framework/resource" + "github.com/hashicorp/terraform-plugin-framework/resource/schema" + "github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier" + "github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier" + "github.com/hashicorp/terraform-plugin-framework/schema/validator" + "github.com/hashicorp/terraform-plugin-framework/types" + "github.com/hashicorp/terraform-plugin-log/tflog" +) + +// Ensure provider defined types fully satisfy framework interfaces +var _ resource.Resource = &ClickPipeReversePrivateEndpointResource{} +var _ resource.ResourceWithImportState = &ClickPipeReversePrivateEndpointResource{} + +const clickPipeReversePrivateEndpointResourceDescription = ` +This experimental resource allows you to create and manage ClickPipes reverse private endpoints for a secure data source connections in ClickHouse Cloud. + +**Resource is early access and may change in future releases. Feature coverage might not fully cover all ClickPipe capabilities.** +` + +func NewClickPipeReversePrivateEndpointResource() resource.Resource { + return &ClickPipeReversePrivateEndpointResource{} +} + +// ClickPipeReversePrivateEndpointResource defines the resource implementation. +type ClickPipeReversePrivateEndpointResource struct { + client *api.ClientImpl +} + +func (r *ClickPipeReversePrivateEndpointResource) Metadata(ctx context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) { + resp.TypeName = req.ProviderTypeName + "_clickpipes_reverse_private_endpoint" +} + +func (r *ClickPipeReversePrivateEndpointResource) Schema(ctx context.Context, req resource.SchemaRequest, resp *resource.SchemaResponse) { + resp.Schema = schema.Schema{ + MarkdownDescription: clickPipeReversePrivateEndpointResourceDescription, + Attributes: map[string]schema.Attribute{ + "id": schema.StringAttribute{ + Computed: true, + MarkdownDescription: "Unique identifier for the reverse private endpoint", + PlanModifiers: []planmodifier.String{ + stringplanmodifier.UseStateForUnknown(), + stringplanmodifier.RequiresReplace(), + }, + }, + "service_id": schema.StringAttribute{ + Required: true, + MarkdownDescription: "The ID of the ClickHouse service to associate with this reverse private endpoint", + PlanModifiers: []planmodifier.String{ + stringplanmodifier.RequiresReplace(), + }, + }, + "description": schema.StringAttribute{ + Required: true, + MarkdownDescription: "Description of the reverse private endpoint", + PlanModifiers: []planmodifier.String{ + stringplanmodifier.RequiresReplace(), + }, + }, + "type": schema.StringAttribute{ + Required: true, + MarkdownDescription: "Type of the reverse private endpoint (VPC_ENDPOINT_SERVICE, VPC_RESOURCE, or MSK_MULTI_VPC)", + Validators: []validator.String{ + stringvalidator.OneOf(api.ReversePrivateEndpointTypes...), + }, + PlanModifiers: []planmodifier.String{ + stringplanmodifier.RequiresReplace(), + }, + }, + "vpc_endpoint_service_name": schema.StringAttribute{ + Optional: true, + MarkdownDescription: "VPC endpoint service name, required for VPC_ENDPOINT_SERVICE type", + PlanModifiers: []planmodifier.String{ + stringplanmodifier.RequiresReplace(), + }, + }, + "vpc_resource_configuration_id": schema.StringAttribute{ + Optional: true, + MarkdownDescription: "VPC resource configuration ID, required for VPC_RESOURCE type", + PlanModifiers: []planmodifier.String{ + stringplanmodifier.RequiresReplace(), + }, + }, + "vpc_resource_share_arn": schema.StringAttribute{ + Optional: true, + MarkdownDescription: "VPC resource share ARN, required for VPC_RESOURCE type", + PlanModifiers: []planmodifier.String{ + stringplanmodifier.RequiresReplace(), + }, + }, + "msk_cluster_arn": schema.StringAttribute{ + Optional: true, + MarkdownDescription: "MSK cluster ARN, required for MSK_MULTI_VPC type", + PlanModifiers: []planmodifier.String{ + stringplanmodifier.RequiresReplace(), + }, + }, + "msk_authentication": schema.StringAttribute{ + Optional: true, + MarkdownDescription: "MSK cluster authentication type (SASL_IAM or SASL_SCRAM), required for MSK_MULTI_VPC type", + Validators: []validator.String{ + stringvalidator.OneOf(api.MSKAuthenticationTypes...), + }, + PlanModifiers: []planmodifier.String{ + stringplanmodifier.RequiresReplace(), + }, + }, + "endpoint_id": schema.StringAttribute{ + Computed: true, + MarkdownDescription: "Reverse private endpoint endpoint ID", + }, + "dns_names": schema.ListAttribute{ + Computed: true, + ElementType: types.StringType, + MarkdownDescription: "Reverse private endpoint internal DNS names", + }, + "private_dns_names": schema.ListAttribute{ + Computed: true, + ElementType: types.StringType, + MarkdownDescription: "Reverse private endpoint private DNS names", + }, + "status": schema.StringAttribute{ + Computed: true, + MarkdownDescription: "Status of the reverse private endpoint", + }, + }, + } +} + +func (r *ClickPipeReversePrivateEndpointResource) Configure(ctx context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) { + // Prevent panic if the provider has not been configured. + if req.ProviderData == nil { + return + } + + client, ok := req.ProviderData.(*api.ClientImpl) + if !ok { + resp.Diagnostics.AddError( + "Unexpected Resource Configure Type", + fmt.Sprintf("Expected *api.ClientImpl, got: %T. Please report this issue to the provider developers.", req.ProviderData), + ) + return + } + + r.client = client +} + +func (r *ClickPipeReversePrivateEndpointResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) { + var data models.ClickPipeReversePrivateEndpointResourceModel + + // Read Terraform plan data into the model + resp.Diagnostics.Append(req.Plan.Get(ctx, &data)...) + if resp.Diagnostics.HasError() { + return + } + + serviceID := data.ServiceID.ValueString() + + // Validate fields based on type + switch data.Type.ValueString() { + case api.ReversePrivateEndpointTypeVPCEndpointService: + if data.VPCEndpointServiceName.IsNull() { + resp.Diagnostics.AddError( + "Missing required field", + "vpc_endpoint_service_name is required when type is VPC_ENDPOINT_SERVICE", + ) + return + } + case api.ReversePrivateEndpointTypeVPCResource: + if data.VPCResourceConfigurationID.IsNull() || data.VPCResourceShareArn.IsNull() { + resp.Diagnostics.AddError( + "Missing required fields", + "vpc_resource_configuration_id and vpc_resource_share_arn are required when type is VPC_RESOURCE", + ) + return + } + case api.ReversePrivateEndpointTypeMSKMultiVPC: + if data.MSKClusterArn.IsNull() || data.MSKAuthentication.IsNull() { + resp.Diagnostics.AddError( + "Missing required fields", + "msk_cluster_arn and msk_authentication are required when type is MSK_MULTI_VPC", + ) + return + } + } + + createReq := api.CreateReversePrivateEndpoint{ + Description: data.Description.ValueString(), + Type: data.Type.ValueString(), + } + + // Set optional fields if provided + if !data.VPCEndpointServiceName.IsNull() { + value := data.VPCEndpointServiceName.ValueString() + createReq.VPCEndpointServiceName = &value + } + if !data.VPCResourceConfigurationID.IsNull() { + value := data.VPCResourceConfigurationID.ValueString() + createReq.VPCResourceConfigurationID = &value + } + if !data.VPCResourceShareArn.IsNull() { + value := data.VPCResourceShareArn.ValueString() + createReq.VPCResourceShareArn = &value + } + if !data.MSKClusterArn.IsNull() { + value := data.MSKClusterArn.ValueString() + createReq.MSKClusterArn = &value + } + if !data.MSKAuthentication.IsNull() { + value := data.MSKAuthentication.ValueString() + createReq.MSKAuthentication = &value + } + + // Create new reverse private endpoint + tflog.Debug(ctx, "Creating ClickPipe reverse private endpoint", map[string]interface{}{ + "service_id": serviceID, + }) + + endpoint, err := r.client.CreateReversePrivateEndpoint(ctx, serviceID, createReq) + if err != nil { + resp.Diagnostics.AddError("Error creating ClickPipe reverse private endpoint", err.Error()) + return + } + + // Wait for the reverse private endpoint status change from provisioning, + // We expect the endpoint to be in a ready state, however, it can also be in + // pending acceptance or failed. This will be handled by the provider user. + endpoint, err = r.client.WaitForReversePrivateEndpointState(ctx, serviceID, endpoint.ID, func(status string) bool { + return status != api.ReversePrivateEndpointStatusProvisioning + }, 60*10) + + if err != nil { + resp.Diagnostics.AddError("Error waiting for ClickPipe reverse private endpoint to be ready", err.Error()) + return + } + + // Map response body to model + data.ID = types.StringValue(endpoint.ID) + data.ServiceID = types.StringValue(serviceID) // Ensure we set the service ID + data.Description = types.StringValue(endpoint.Description) + data.Type = types.StringValue(endpoint.Type) + data.EndpointID = types.StringValue(endpoint.EndpointID) + data.Status = types.StringValue(endpoint.Status) + + if endpoint.VPCEndpointServiceName != nil { + data.VPCEndpointServiceName = types.StringValue(*endpoint.VPCEndpointServiceName) + } else { + data.VPCEndpointServiceName = types.StringNull() + } + + if endpoint.VPCResourceConfigurationID != nil { + data.VPCResourceConfigurationID = types.StringValue(*endpoint.VPCResourceConfigurationID) + } else { + data.VPCResourceConfigurationID = types.StringNull() + } + + if endpoint.VPCResourceShareArn != nil { + data.VPCResourceShareArn = types.StringValue(*endpoint.VPCResourceShareArn) + } else { + data.VPCResourceShareArn = types.StringNull() + } + + if endpoint.MSKClusterArn != nil { + data.MSKClusterArn = types.StringValue(*endpoint.MSKClusterArn) + } else { + data.MSKClusterArn = types.StringNull() + } + + if endpoint.MSKAuthentication != nil { + data.MSKAuthentication = types.StringValue(*endpoint.MSKAuthentication) + } else { + data.MSKAuthentication = types.StringNull() + } + + // Convert string slices to Terraform list values + dnsNames, diags := types.ListValueFrom(ctx, types.StringType, endpoint.DNSNames) + resp.Diagnostics.Append(diags...) + data.DNSNames = dnsNames + + privateDNSNames, diags := types.ListValueFrom(ctx, types.StringType, endpoint.PrivateDNSNames) + resp.Diagnostics.Append(diags...) + data.PrivateDNSNames = privateDNSNames + + // Save data into Terraform state + resp.Diagnostics.Append(resp.State.Set(ctx, &data)...) +} + +func (r *ClickPipeReversePrivateEndpointResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) { + var data models.ClickPipeReversePrivateEndpointResourceModel + + // Read Terraform prior state data into the model + resp.Diagnostics.Append(req.State.Get(ctx, &data)...) + if resp.Diagnostics.HasError() { + return + } + + serviceID := data.ServiceID.ValueString() + endpointID := data.ID.ValueString() + + tflog.Debug(ctx, "Reading ClickPipe reverse private endpoint", map[string]interface{}{ + "service_id": serviceID, + "endpoint_id": endpointID, + }) + + endpoint, err := r.client.GetReversePrivateEndpoint(ctx, serviceID, endpointID) + if err != nil { + if api.IsNotFound(err) { + // If the resource doesn't exist, remove it from state + resp.State.RemoveResource(ctx) + return + } + resp.Diagnostics.AddError("Error reading ClickPipe reverse private endpoint", err.Error()) + return + } + + // Map response body to model + data.ID = types.StringValue(endpoint.ID) + data.ServiceID = types.StringValue(serviceID) // Ensure we keep the service ID + data.Description = types.StringValue(endpoint.Description) + data.Type = types.StringValue(endpoint.Type) + data.EndpointID = types.StringValue(endpoint.EndpointID) + data.Status = types.StringValue(endpoint.Status) + + if endpoint.VPCEndpointServiceName != nil { + data.VPCEndpointServiceName = types.StringValue(*endpoint.VPCEndpointServiceName) + } else { + data.VPCEndpointServiceName = types.StringNull() + } + + if endpoint.VPCResourceConfigurationID != nil { + data.VPCResourceConfigurationID = types.StringValue(*endpoint.VPCResourceConfigurationID) + } else { + data.VPCResourceConfigurationID = types.StringNull() + } + + if endpoint.VPCResourceShareArn != nil { + data.VPCResourceShareArn = types.StringValue(*endpoint.VPCResourceShareArn) + } else { + data.VPCResourceShareArn = types.StringNull() + } + + if endpoint.MSKClusterArn != nil { + data.MSKClusterArn = types.StringValue(*endpoint.MSKClusterArn) + } else { + data.MSKClusterArn = types.StringNull() + } + + if endpoint.MSKAuthentication != nil { + data.MSKAuthentication = types.StringValue(*endpoint.MSKAuthentication) + } else { + data.MSKAuthentication = types.StringNull() + } + + // Convert string slices to Terraform list values + dnsNames, diags := types.ListValueFrom(ctx, types.StringType, endpoint.DNSNames) + resp.Diagnostics.Append(diags...) + data.DNSNames = dnsNames + + privateDNSNames, diags := types.ListValueFrom(ctx, types.StringType, endpoint.PrivateDNSNames) + resp.Diagnostics.Append(diags...) + data.PrivateDNSNames = privateDNSNames + + // Save updated data into Terraform state + resp.Diagnostics.Append(resp.State.Set(ctx, &data)...) +} + +func (r *ClickPipeReversePrivateEndpointResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) { + // According to the API, reverse private endpoints don't support updates, so we'll return an error + resp.Diagnostics.AddError( + "Update Not Supported", + "ClickPipe reverse private endpoints do not support updates. To change configuration, please delete and recreate the resource.", + ) +} + +func (r *ClickPipeReversePrivateEndpointResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) { + var data models.ClickPipeReversePrivateEndpointResourceModel + + // Read Terraform prior state data into the model + resp.Diagnostics.Append(req.State.Get(ctx, &data)...) + if resp.Diagnostics.HasError() { + return + } + + serviceID := data.ServiceID.ValueString() + endpointID := data.ID.ValueString() + + tflog.Debug(ctx, "Deleting ClickPipe reverse private endpoint", map[string]interface{}{ + "service_id": serviceID, + "endpoint_id": endpointID, + }) + + err := r.client.DeleteReversePrivateEndpoint(ctx, serviceID, endpointID) + if err != nil { + resp.Diagnostics.AddError("Error deleting ClickPipe reverse private endpoint", err.Error()) + return + } + + err = backoff.Retry(func() error { + rpe, err := r.client.GetReversePrivateEndpoint(ctx, serviceID, endpointID) + + if err != nil { + if api.IsNotFound(err) { + return nil // Successfully deleted + } + return err + } + + return fmt.Errorf("ClickPipe reverse private endpoint %s is still present", rpe.ID) + }, backoff.WithMaxRetries(backoff.NewConstantBackOff(5*time.Second), 60*10)) + + if err != nil { + resp.Diagnostics.AddError("Error waiting for ClickPipe reverse private endpoint to be deleted", err.Error()) + return + } +} + +// ImportState imports a ClickPipe reverse private endpoint into the state. +func (r *ClickPipeReversePrivateEndpointResource) ImportState(ctx context.Context, req resource.ImportStateRequest, resp *resource.ImportStateResponse) { + idParts := strings.Split(req.ID, ":") + + if len(idParts) != 2 { + resp.Diagnostics.AddError( + "Invalid Import ID", + fmt.Sprintf("Expected import identifier with format: service_id:id. Got: %q", req.ID), + ) + return + } + + id := idParts[0] + endpointID := idParts[1] + + resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("service_id"), id)...) + resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("id"), endpointID)...) +} diff --git a/pkg/resource/models/clickpipe_resource.go b/pkg/resource/models/clickpipe_resource.go index cc782844..251f4dc9 100644 --- a/pkg/resource/models/clickpipe_resource.go +++ b/pkg/resource/models/clickpipe_resource.go @@ -161,39 +161,43 @@ type ClickPipeKafkaSourceModel struct { Credentials types.Object `tfsdk:"credentials"` IAMRole types.String `tfsdk:"iam_role"` CACertificate types.String `tfsdk:"ca_certificate"` + + ReversePrivateEndpointIDs types.List `tfsdk:"reverse_private_endpoint_ids"` } func (m ClickPipeKafkaSourceModel) ObjectType() types.ObjectType { return types.ObjectType{ AttrTypes: map[string]attr.Type{ - "type": types.StringType, - "format": types.StringType, - "brokers": types.StringType, - "topics": types.StringType, - "consumer_group": types.StringType, - "offset": ClickPipeKafkaOffsetModel{}.ObjectType(), - "schema_registry": ClickPipeKafkaSchemaRegistryModel{}.ObjectType(), - "authentication": types.StringType, - "credentials": ClickPipeKafkaSourceCredentialsModel{}.ObjectType(), - "iam_role": types.StringType, - "ca_certificate": types.StringType, + "type": types.StringType, + "format": types.StringType, + "brokers": types.StringType, + "topics": types.StringType, + "consumer_group": types.StringType, + "offset": ClickPipeKafkaOffsetModel{}.ObjectType(), + "schema_registry": ClickPipeKafkaSchemaRegistryModel{}.ObjectType(), + "authentication": types.StringType, + "credentials": ClickPipeKafkaSourceCredentialsModel{}.ObjectType(), + "iam_role": types.StringType, + "ca_certificate": types.StringType, + "reverse_private_endpoint_ids": types.ListType{ElemType: types.StringType}, }, } } func (m ClickPipeKafkaSourceModel) ObjectValue() types.Object { return types.ObjectValueMust(m.ObjectType().AttrTypes, map[string]attr.Value{ - "type": m.Type, - "format": m.Format, - "brokers": m.Brokers, - "topics": m.Topics, - "consumer_group": m.ConsumerGroup, - "offset": m.Offset, - "schema_registry": m.SchemaRegistry, - "authentication": m.Authentication, - "credentials": m.Credentials, - "iam_role": m.IAMRole, - "ca_certificate": m.CACertificate, + "type": m.Type, + "format": m.Format, + "brokers": m.Brokers, + "topics": m.Topics, + "consumer_group": m.ConsumerGroup, + "offset": m.Offset, + "schema_registry": m.SchemaRegistry, + "authentication": m.Authentication, + "credentials": m.Credentials, + "iam_role": m.IAMRole, + "ca_certificate": m.CACertificate, + "reverse_private_endpoint_ids": m.ReversePrivateEndpointIDs, }) } diff --git a/pkg/resource/models/clickpipe_reverse_private_endpoint_resource.go b/pkg/resource/models/clickpipe_reverse_private_endpoint_resource.go new file mode 100644 index 00000000..9a2bb9bd --- /dev/null +++ b/pkg/resource/models/clickpipe_reverse_private_endpoint_resource.go @@ -0,0 +1,24 @@ +//go:build alpha + +package models + +import ( + "github.com/hashicorp/terraform-plugin-framework/types" +) + +// ClickPipeReversePrivateEndpointResourceModel describes the resource data model. +type ClickPipeReversePrivateEndpointResourceModel struct { + ID types.String `tfsdk:"id"` + ServiceID types.String `tfsdk:"service_id"` + Description types.String `tfsdk:"description"` + Type types.String `tfsdk:"type"` + VPCEndpointServiceName types.String `tfsdk:"vpc_endpoint_service_name"` + VPCResourceConfigurationID types.String `tfsdk:"vpc_resource_configuration_id"` + VPCResourceShareArn types.String `tfsdk:"vpc_resource_share_arn"` + MSKClusterArn types.String `tfsdk:"msk_cluster_arn"` + MSKAuthentication types.String `tfsdk:"msk_authentication"` + EndpointID types.String `tfsdk:"endpoint_id"` + DNSNames types.List `tfsdk:"dns_names"` + PrivateDNSNames types.List `tfsdk:"private_dns_names"` + Status types.String `tfsdk:"status"` +} diff --git a/pkg/resource/register_debug.go b/pkg/resource/register_debug.go index cdf2cd21..aef81211 100644 --- a/pkg/resource/register_debug.go +++ b/pkg/resource/register_debug.go @@ -13,6 +13,7 @@ func GetResourceFactories() []func() upstreamresource.Resource { NewServicePrivateEndpointsAttachmentResource, NewDatabaseResource, NewClickPipeResource, + NewClickPipeReversePrivateEndpointResource, NewUserResource, NewRoleResource, NewGrantRoleResource,