public async stt::Task MutateAdGroupsAsync()
        {
            moq::Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new moq::Mock <AdGroupService.AdGroupServiceClient>(moq::MockBehavior.Strict);
            MutateAdGroupsRequest request = new MutateAdGroupsRequest
            {
                CustomerId = "customer_id3b3724cb",
                Operations =
                {
                    new AdGroupOperation(),
                },
            };
            MutateAdGroupsResponse expectedResponse = new MutateAdGroupsResponse
            {
                Results =
                {
                    new MutateAdGroupResult(),
                },
                PartialFailureError = new gr::Status(),
            };

            mockGrpcClient.Setup(x => x.MutateAdGroupsAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <MutateAdGroupsResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            AdGroupServiceClient   client = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            MutateAdGroupsResponse responseCallSettings = await client.MutateAdGroupsAsync(request.CustomerId, request.Operations, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            MutateAdGroupsResponse responseCancellationToken = await client.MutateAdGroupsAsync(request.CustomerId, request.Operations, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void MutateAdGroupsRequestObject()
        {
            moq::Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new moq::Mock <AdGroupService.AdGroupServiceClient>(moq::MockBehavior.Strict);
            MutateAdGroupsRequest request = new MutateAdGroupsRequest
            {
                CustomerId = "customer_id3b3724cb",
                Operations =
                {
                    new AdGroupOperation(),
                },
                PartialFailure      = false,
                ValidateOnly        = true,
                ResponseContentType = gagve::ResponseContentTypeEnum.Types.ResponseContentType.ResourceNameOnly,
            };
            MutateAdGroupsResponse expectedResponse = new MutateAdGroupsResponse
            {
                Results =
                {
                    new MutateAdGroupResult(),
                },
                PartialFailureError = new gr::Status(),
            };

            mockGrpcClient.Setup(x => x.MutateAdGroups(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            AdGroupServiceClient   client   = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            MutateAdGroupsResponse response = client.MutateAdGroups(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void MutateAdGroups()
        {
            moq::Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new moq::Mock <AdGroupService.AdGroupServiceClient>(moq::MockBehavior.Strict);
            MutateAdGroupsRequest request = new MutateAdGroupsRequest
            {
                CustomerId = "customer_id3b3724cb",
                Operations =
                {
                    new AdGroupOperation(),
                },
            };
            MutateAdGroupsResponse expectedResponse = new MutateAdGroupsResponse
            {
                Results =
                {
                    new MutateAdGroupResult(),
                },
                PartialFailureError = new gr::Status(),
            };

            mockGrpcClient.Setup(x => x.MutateAdGroups(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            AdGroupServiceClient   client   = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            MutateAdGroupsResponse response = client.MutateAdGroups(request.CustomerId, request.Operations);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task GetAdGroupRequestObjectAsync()
        {
            moq::Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new moq::Mock <AdGroupService.AdGroupServiceClient>(moq::MockBehavior.Strict);
            GetAdGroupRequest request = new GetAdGroupRequest
            {
                ResourceNameAsAdGroupName = gagvr::AdGroupName.FromCustomerAdGroup("[CUSTOMER_ID]", "[AD_GROUP_ID]"),
            };
            gagvr::AdGroup expectedResponse = new gagvr::AdGroup
            {
                ResourceNameAsAdGroupName = gagvr::AdGroupName.FromCustomerAdGroup("[CUSTOMER_ID]", "[AD_GROUP_ID]"),
                Status = gagve::AdGroupStatusEnum.Types.AdGroupStatus.Removed,
                UrlCustomParameters =
                {
                    new gagvc::CustomParameter(),
                },
                Type = gagve::AdGroupTypeEnum.Types.AdGroupType.VideoTrueViewInDisplay,
                ExplorerAutoOptimizerSetting = new gagvc::ExplorerAutoOptimizerSetting(),
                AdRotationMode            = gagve::AdGroupAdRotationModeEnum.Types.AdGroupAdRotationMode.Unspecified,
                DisplayCustomBidDimension = gagve::TargetingDimensionEnum.Types.TargetingDimension.AgeRange,
                TargetingSetting          = new gagvc::TargetingSetting(),
                EffectiveTargetCpaSource  = gagve::BiddingSourceEnum.Types.BiddingSource.Unknown,
                EffectiveTargetRoasSource = gagve::BiddingSourceEnum.Types.BiddingSource.AdGroupCriterion,
                Id          = -6774108720365892680L,
                AdGroupName = gagvr::AdGroupName.FromCustomerAdGroup("[CUSTOMER_ID]", "[AD_GROUP_ID]"),
                BaseAdGroupAsAdGroupName = gagvr::AdGroupName.FromCustomerAdGroup("[CUSTOMER_ID]", "[AD_GROUP_ID]"),
                TrackingUrlTemplate      = "tracking_url_template157f152a",
                CampaignAsCampaignName   = gagvr::CampaignName.FromCustomerCampaign("[CUSTOMER_ID]", "[CAMPAIGN_ID]"),
                CpcBidMicros             = 7321761304249472746L,
                CpmBidMicros             = -6938481569984464040L,
                TargetCpaMicros          = 5263516020894046876L,
                CpvBidMicros             = 3393527949878021854L,
                TargetCpmMicros          = 2683842186664132327L,
                TargetRoas                = 1.0830159587289216E+18,
                PercentCpcBidMicros       = 3342096754779167220L,
                FinalUrlSuffix            = "final_url_suffix046ed37a",
                EffectiveTargetCpaMicros  = 9173558632194584770L,
                EffectiveTargetRoas       = -5.789428044530098E+17,
                LabelsAsAdGroupLabelNames =
                {
                    gagvr::AdGroupLabelName.FromCustomerAdGroupLabel("[CUSTOMER_ID]", "[AD_GROUP_ID]", "[LABEL_ID]"),
                },
                ExcludedParentAssetFieldTypes =
                {
                    gagve::AssetFieldTypeEnum.Types.AssetFieldType.HotelCallout,
                },
            };

            mockGrpcClient.Setup(x => x.GetAdGroupAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <gagvr::AdGroup>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            AdGroupServiceClient client = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            gagvr::AdGroup       responseCallSettings = await client.GetAdGroupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            Assert.AreEqual(expectedResponse, responseCallSettings);
            gagvr::AdGroup responseCancellationToken = await client.GetAdGroupAsync(request, st::CancellationToken.None);

            Assert.AreEqual(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void GetAdGroupRequestObject()
        {
            moq::Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new moq::Mock <AdGroupService.AdGroupServiceClient>(moq::MockBehavior.Strict);
            GetAdGroupRequest request = new GetAdGroupRequest
            {
                ResourceNameAsAdGroupName = gagvr::AdGroupName.FromCustomerAdGroup("[CUSTOMER]", "[AD_GROUP]"),
            };
            gagvr::AdGroup expectedResponse = new gagvr::AdGroup
            {
                ResourceNameAsAdGroupName = gagvr::AdGroupName.FromCustomerAdGroup("[CUSTOMER]", "[AD_GROUP]"),
                Id                  = -6774108720365892680L,
                AdGroupName         = gagvr::AdGroupName.FromCustomerAdGroup("[CUSTOMER]", "[AD_GROUP]"),
                Status              = gagve::AdGroupStatusEnum.Types.AdGroupStatus.Removed,
                UrlCustomParameters =
                {
                    new gagvc::CustomParameter(),
                },
                CampaignAsCampaignName = gagvr::CampaignName.FromCustomerCampaign("[CUSTOMER]", "[CAMPAIGN]"),
                Type = gagve::AdGroupTypeEnum.Types.AdGroupType.VideoBumper,
                TrackingUrlTemplate          = "tracking_url_template157f152a",
                CpcBidMicros                 = 7321761304249472746L,
                CpmBidMicros                 = -6938481569984464040L,
                CpvBidMicros                 = 3393527949878021854L,
                BaseAdGroupAsAdGroupName     = gagvr::AdGroupName.FromCustomerAdGroup("[CUSTOMER]", "[AD_GROUP]"),
                PercentCpcBidMicros          = 3342096754779167220L,
                ExplorerAutoOptimizerSetting = new gagvc::ExplorerAutoOptimizerSetting(),
                AdRotationMode               = gagve::AdGroupAdRotationModeEnum.Types.AdGroupAdRotationMode.Unspecified,
                DisplayCustomBidDimension    = gagve::TargetingDimensionEnum.Types.TargetingDimension.AgeRange,
                FinalUrlSuffix               = "final_url_suffix046ed37a",
                TargetingSetting             = new gagvc::TargetingSetting(),
                TargetCpmMicros              = 2683842186664132327L,
                TargetCpaMicros              = 5263516020894046876L,
                EffectiveTargetCpaMicros     = 9173558632194584770L,
                EffectiveTargetCpaSource     = gagve::BiddingSourceEnum.Types.BiddingSource.Unknown,
                TargetRoas                = 1.0830159587289216E+18,
                EffectiveTargetRoas       = -5.789428044530098E+17,
                EffectiveTargetRoasSource = gagve::BiddingSourceEnum.Types.BiddingSource.AdGroupCriterion,
                LabelsAsAdGroupLabelNames =
                {
                    gagvr::AdGroupLabelName.FromCustomerAdGroupLabel("[CUSTOMER]", "[AD_GROUP_LABEL]"),
                },
            };

            mockGrpcClient.Setup(x => x.GetAdGroup(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            AdGroupServiceClient client   = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            gagvr::AdGroup       response = client.GetAdGroup(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task MutateAdGroupsAsync2()
        {
            Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new Mock <AdGroupService.AdGroupServiceClient>(MockBehavior.Strict);
            MutateAdGroupsRequest request = new MutateAdGroupsRequest
            {
                CustomerId = "customerId-1772061412",
                Operations = { },
            };
            MutateAdGroupsResponse expectedResponse = new MutateAdGroupsResponse();

            mockGrpcClient.Setup(x => x.MutateAdGroupsAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <MutateAdGroupsResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            AdGroupServiceClient   client   = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            MutateAdGroupsResponse response = await client.MutateAdGroupsAsync(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void MutateAdGroups2()
        {
            Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new Mock <AdGroupService.AdGroupServiceClient>(MockBehavior.Strict);
            MutateAdGroupsRequest request = new MutateAdGroupsRequest
            {
                CustomerId = "customerId-1772061412",
                Operations = { },
            };
            MutateAdGroupsResponse expectedResponse = new MutateAdGroupsResponse();

            mockGrpcClient.Setup(x => x.MutateAdGroups(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            AdGroupServiceClient   client   = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            MutateAdGroupsResponse response = client.MutateAdGroups(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void GetAdGroup2()
        {
            Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new Mock <AdGroupService.AdGroupServiceClient>(MockBehavior.Strict);
            GetAdGroupRequest request = new GetAdGroupRequest
            {
                ResourceName = new AdGroupName("[CUSTOMER]", "[AD_GROUP]").ToString(),
            };
            AdGroup expectedResponse = new AdGroup
            {
                ResourceName = "resourceName2625949903",
            };

            mockGrpcClient.Setup(x => x.GetAdGroup(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            AdGroupServiceClient client = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            AdGroup response            = client.GetAdGroup(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task GetAdGroupAsync2()
        {
            Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new Mock <AdGroupService.AdGroupServiceClient>(MockBehavior.Strict);
            GetAdGroupRequest request = new GetAdGroupRequest
            {
                ResourceName = new AdGroupName("[CUSTOMER]", "[AD_GROUP]").ToString(),
            };
            AdGroup expectedResponse = new AdGroup
            {
                ResourceName = "resourceName2625949903",
            };

            mockGrpcClient.Setup(x => x.GetAdGroupAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <AdGroup>(Task.FromResult(expectedResponse), null, null, null, null));
            AdGroupServiceClient client = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            AdGroup response            = await client.GetAdGroupAsync(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
예제 #10
0
        public async Task MutateAdGroupsAsync()
        {
            Mock <AdGroupService.AdGroupServiceClient> mockGrpcClient = new Mock <AdGroupService.AdGroupServiceClient>(MockBehavior.Strict);
            MutateAdGroupsRequest expectedRequest = new MutateAdGroupsRequest
            {
                CustomerId     = "customerId-1772061412",
                Operations     = { },
                PartialFailure = true,
                ValidateOnly   = false,
            };
            MutateAdGroupsResponse expectedResponse = new MutateAdGroupsResponse();

            mockGrpcClient.Setup(x => x.MutateAdGroupsAsync(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <MutateAdGroupsResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            AdGroupServiceClient client = new AdGroupServiceClientImpl(mockGrpcClient.Object, null);
            string customerId           = "customerId-1772061412";
            IEnumerable <AdGroupOperation> operations = new List <AdGroupOperation>();
            bool partialFailure             = true;
            bool validateOnly               = false;
            MutateAdGroupsResponse response = await client.MutateAdGroupsAsync(customerId, operations, partialFailure, validateOnly);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }