Пример #1
0
        public async Task GenerateKeywordIdeasAsync()
        {
            Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient> mockGrpcClient = new Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient>(MockBehavior.Strict);
            GenerateKeywordIdeasRequest expectedRequest = new GenerateKeywordIdeasRequest
            {
                CustomerId         = "customerId-1772061412",
                Language           = null,
                GeoTargetConstants = { },
                KeywordPlanNetwork = KeywordPlanNetworkEnum.Types.KeywordPlanNetwork.Unspecified,
            };
            GenerateKeywordIdeaResponse expectedResponse = new GenerateKeywordIdeaResponse();

            mockGrpcClient.Setup(x => x.GenerateKeywordIdeasAsync(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <GenerateKeywordIdeaResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            KeywordPlanIdeaServiceClient client = new KeywordPlanIdeaServiceClientImpl(mockGrpcClient.Object, null);
            string customerId = "customerId-1772061412";
            string language   = null;
            IEnumerable <string> geoTargetConstants = new List <string>();

            KeywordPlanNetworkEnum.Types.KeywordPlanNetwork keywordPlanNetwork = KeywordPlanNetworkEnum.Types.KeywordPlanNetwork.Unspecified;
            GenerateKeywordIdeaResponse response = await client.GenerateKeywordIdeasAsync(customerId, language, geoTargetConstants, keywordPlanNetwork);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Пример #2
0
        public void GenerateKeywordIdeas()
        {
            Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient> mockGrpcClient = new Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient>(MockBehavior.Strict);
            string customerId = "customerId-1772061412";
            string language   = "en";
            GenerateKeywordIdeasRequest expectedRequest = new GenerateKeywordIdeasRequest
            {
                CustomerId         = customerId,
                Language           = language,
                GeoTargetConstants = { },
                KeywordPlanNetwork = KeywordPlanNetworkEnum.Types.KeywordPlanNetwork.Unspecified,
            };
            GenerateKeywordIdeaResponse expectedResponse = new GenerateKeywordIdeaResponse();

            mockGrpcClient.Setup(x => x.GenerateKeywordIdeas(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            KeywordPlanIdeaServiceClient client             = new KeywordPlanIdeaServiceClientImpl(mockGrpcClient.Object, null);
            IEnumerable <string>         geoTargetConstants = new List <string>();

            KeywordPlanNetworkEnum.Types.KeywordPlanNetwork keywordPlanNetwork = KeywordPlanNetworkEnum.Types.KeywordPlanNetwork.Unspecified;
            GenerateKeywordIdeaResponse response = client.GenerateKeywordIdeas(customerId, language, geoTargetConstants, keywordPlanNetwork);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task GenerateKeywordIdeasRequestObjectAsync()
        {
            moq::Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient> mockGrpcClient = new moq::Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient>(moq::MockBehavior.Strict);
            GenerateKeywordIdeasRequest request = new GenerateKeywordIdeasRequest
            {
                CustomerId         = "customer_id3b3724cb",
                KeywordAndUrlSeed  = new KeywordAndUrlSeed(),
                KeywordSeed        = new KeywordSeed(),
                UrlSeed            = new UrlSeed(),
                Language           = "language7dae1285",
                GeoTargetConstants =
                {
                    "geo_target_constants2f692206",
                },
                KeywordPlanNetwork = gagve::KeywordPlanNetworkEnum.Types.KeywordPlanNetwork.Unspecified,
            };
            GenerateKeywordIdeaResponse expectedResponse = new GenerateKeywordIdeaResponse
            {
                Results =
                {
                    new GenerateKeywordIdeaResult(),
                },
            };

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

            Assert.AreEqual(expectedResponse, responseCallSettings);
            GenerateKeywordIdeaResponse responseCancellationToken = await client.GenerateKeywordIdeasAsync(request, st::CancellationToken.None);

            Assert.AreEqual(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void GenerateKeywordIdeasRequestObject()
        {
            moq::Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient> mockGrpcClient = new moq::Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient>(moq::MockBehavior.Strict);
            GenerateKeywordIdeasRequest request = new GenerateKeywordIdeasRequest
            {
                CustomerId         = "customer_id3b3724cb",
                KeywordAndUrlSeed  = new KeywordAndUrlSeed(),
                KeywordSeed        = new KeywordSeed(),
                UrlSeed            = new UrlSeed(),
                Language           = "language7dae1285",
                GeoTargetConstants =
                {
                    "geo_target_constants2f692206",
                },
                KeywordPlanNetwork = gagve::KeywordPlanNetworkEnum.Types.KeywordPlanNetwork.Unspecified,
            };
            GenerateKeywordIdeaResponse expectedResponse = new GenerateKeywordIdeaResponse
            {
                Results =
                {
                    new GenerateKeywordIdeaResult(),
                },
            };

            mockGrpcClient.Setup(x => x.GenerateKeywordIdeas(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            KeywordPlanIdeaServiceClient client   = new KeywordPlanIdeaServiceClientImpl(mockGrpcClient.Object, null);
            GenerateKeywordIdeaResponse  response = client.GenerateKeywordIdeas(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void GenerateKeywordIdeas2()
        {
            Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient> mockGrpcClient = new Mock <KeywordPlanIdeaService.KeywordPlanIdeaServiceClient>(MockBehavior.Strict);
            GenerateKeywordIdeasRequest request = new GenerateKeywordIdeasRequest
            {
                CustomerId = "customerId-1772061412",
                Language   = new StringValue().Value,
                // TODO(liseno): Implicit type cast from StringValue to String failed,
                GeoTargetConstants = { },
                KeywordPlanNetwork = KeywordPlanNetworkEnum.Types.KeywordPlanNetwork.Unspecified,
            };
            GenerateKeywordIdeaResponse expectedResponse = new GenerateKeywordIdeaResponse();

            mockGrpcClient.Setup(x => x.GenerateKeywordIdeas(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            KeywordPlanIdeaServiceClient client   = new KeywordPlanIdeaServiceClientImpl(mockGrpcClient.Object, null);
            GenerateKeywordIdeaResponse  response = client.GenerateKeywordIdeas(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="client">The Google Ads client.</param>
        /// <param name="customerId">The customer ID for which the call is made.</param>
        /// <param name="locationIds">The list of location IDs to restrict the search.</param>
        /// <param name="languageId">The language to restrict the search.</param>
        /// <param name="keywordTexts">The list of seed keywords.</param>
        /// <param name="pageUrl">The seed page URL.</param>
        public void Run(GoogleAdsClient client, long customerId, long[] locationIds,
                        long languageId, string[] keywordTexts, string pageUrl)
        {
            KeywordPlanIdeaServiceClient keywordPlanIdeaService =
                client.GetService(Services.V2.KeywordPlanIdeaService);

            // Make sure that keywords and/or page URL were specified. The request must have
            // exactly one of urlSeed, keywordSeed, or keywordAndUrlSeed set.
            if (keywordTexts.Length == 0 && string.IsNullOrEmpty(pageUrl))
            {
                throw new ArgumentException("At least one of keywords or page URL is required, " +
                                            "but neither was specified.");
            }

            // Specify the optional arguments of the request as a keywordSeed, UrlSeed,
            // or KeywordAndUrlSeed.
            GenerateKeywordIdeasRequest request = new GenerateKeywordIdeasRequest()
            {
                CustomerId = customerId.ToString(),
            };

            if (keywordTexts.Length == 0)
            {
                // Only page URL was specified, so use a UrlSeed.
                request.UrlSeed = new UrlSeed()
                {
                    Url = pageUrl
                };
            }
            else if (string.IsNullOrEmpty(pageUrl))
            {
                // Only keywords were specified, so use a KeywordSeed.
                request.KeywordSeed = new KeywordSeed();
                request.KeywordSeed.Keywords.AddRange(keywordTexts);
            }
            else
            {
                // Both page URL and keywords were specified, so use a KeywordAndUrlSeed.
                request.KeywordAndUrlSeed     = new KeywordAndUrlSeed();
                request.KeywordAndUrlSeed.Url = pageUrl;
                request.KeywordAndUrlSeed.Keywords.AddRange(keywordTexts);
            }


            // Create a list of geo target constants based on the resource name of specified
            // location IDs.
            foreach (long locationId in locationIds)
            {
                request.GeoTargetConstants.Add(ResourceNames.GeoTargetConstant(locationId));
            }

            request.Language = ResourceNames.LanguageConstant(languageId);
            // Set the network. To restrict to only Google Search, change the parameter below to
            // KeywordPlanNetwork.GoogleSearch.
            request.KeywordPlanNetwork = KeywordPlanNetwork.GoogleSearchAndPartners;

            try
            {
                // Generate keyword ideas based on the specified parameters.
                GenerateKeywordIdeaResponse response =
                    keywordPlanIdeaService.GenerateKeywordIdeas(request);

                // Iterate over the results and print its detail.
                foreach (GenerateKeywordIdeaResult result in response.Results)
                {
                    KeywordPlanHistoricalMetrics metrics = result.KeywordIdeaMetrics;
                    Console.WriteLine($"Keyword idea text '{result.Text}' has " +
                                      $"{metrics.AvgMonthlySearches} average monthly searches and competition " +
                                      $"is {metrics.Competition}.");
                }
            }
            catch (GoogleAdsException e)
            {
                Console.WriteLine("Failure:");
                Console.WriteLine($"Message: {e.Message}");
                Console.WriteLine($"Failure: {e.Failure}");
                Console.WriteLine($"Request ID: {e.RequestId}");
            }
        }