public void MutateUserLists()
        {
            moq::Mock <UserListService.UserListServiceClient> mockGrpcClient = new moq::Mock <UserListService.UserListServiceClient>(moq::MockBehavior.Strict);
            MutateUserListsRequest request = new MutateUserListsRequest
            {
                CustomerId = "customer_id3b3724cb",
                Operations =
                {
                    new UserListOperation(),
                },
            };
            MutateUserListsResponse expectedResponse = new MutateUserListsResponse
            {
                Results =
                {
                    new MutateUserListResult(),
                },
                PartialFailureError = new gr::Status(),
            };

            mockGrpcClient.Setup(x => x.MutateUserLists(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            UserListServiceClient   client   = new UserListServiceClientImpl(mockGrpcClient.Object, null);
            MutateUserListsResponse response = client.MutateUserLists(request.CustomerId, request.Operations);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task MutateUserListsAsync()
        {
            moq::Mock <UserListService.UserListServiceClient> mockGrpcClient = new moq::Mock <UserListService.UserListServiceClient>(moq::MockBehavior.Strict);
            MutateUserListsRequest request = new MutateUserListsRequest
            {
                CustomerId = "customer_id3b3724cb",
                Operations =
                {
                    new UserListOperation(),
                },
            };
            MutateUserListsResponse expectedResponse = new MutateUserListsResponse
            {
                Results =
                {
                    new MutateUserListResult(),
                },
                PartialFailureError = new gr::Status(),
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
예제 #3
0
        public async stt::Task GetUserListRequestObjectAsync()
        {
            moq::Mock <UserListService.UserListServiceClient> mockGrpcClient = new moq::Mock <UserListService.UserListServiceClient>(moq::MockBehavior.Strict);
            GetUserListRequest request = new GetUserListRequest
            {
                ResourceNameAsUserListName = gagvr::UserListName.FromCustomerUserList("[CUSTOMER_ID]", "[USER_LIST_ID]"),
            };
            gagvr::UserList expectedResponse = new gagvr::UserList
            {
                ResourceNameAsUserListName = gagvr::UserListName.FromCustomerUserList("[CUSTOMER_ID]", "[USER_LIST_ID]"),
                MembershipStatus           = gagve::UserListMembershipStatusEnum.Types.UserListMembershipStatus.Open,
                SizeRangeForDisplay        = gagve::UserListSizeRangeEnum.Types.UserListSizeRange.Unknown,
                SizeRangeForSearch         = gagve::UserListSizeRangeEnum.Types.UserListSizeRange.OneHundredThousandToThreeHundredThousand,
                Type                  = gagve::UserListTypeEnum.Types.UserListType.CrmBased,
                ClosingReason         = gagve::UserListClosingReasonEnum.Types.UserListClosingReason.Unused,
                AccessReason          = gagve::AccessReasonEnum.Types.AccessReason.Affiliated,
                AccountUserListStatus = gagve::UserListAccessStatusEnum.Types.UserListAccessStatus.Disabled,
                CrmBasedUserList      = new gagvc::CrmBasedUserListInfo(),
                SimilarUserList       = new gagvc::SimilarUserListInfo(),
                RuleBasedUserList     = new gagvc::RuleBasedUserListInfo(),
                LogicalUserList       = new gagvc::LogicalUserListInfo(),
                BasicUserList         = new gagvc::BasicUserListInfo(),
                MatchRatePercentage   = 696939998,
                Id                 = -6774108720365892680L,
                ReadOnly           = false,
                UserListName       = gagvr::UserListName.FromCustomerUserList("[CUSTOMER_ID]", "[USER_LIST_ID]"),
                Description        = "description2cf9da67",
                IntegrationCode    = "integration_codeb56c28f6",
                MembershipLifeSpan = 8593891943371112615L,
                SizeForDisplay     = -3774093290138442712L,
                SizeForSearch      = 7931927642168968409L,
                EligibleForSearch  = false,
                EligibleForDisplay = true,
            };

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

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            gagvr::UserList responseCancellationToken = await client.GetUserListAsync(request, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public async Task MutateUserListsAsync3()
        {
            Mock <UserListService.UserListServiceClient> mockGrpcClient = new Mock <UserListService.UserListServiceClient>(MockBehavior.Strict);
            MutateUserListsRequest request = new MutateUserListsRequest
            {
                CustomerId = "customerId-1772061412",
                Operations = { },
            };
            MutateUserListsResponse expectedResponse = new MutateUserListsResponse();

            mockGrpcClient.Setup(x => x.MutateUserListsAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <MutateUserListsResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            UserListServiceClient   client   = new UserListServiceClientImpl(mockGrpcClient.Object, null);
            MutateUserListsResponse response = await client.MutateUserListsAsync(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void MutateUserLists3()
        {
            Mock <UserListService.UserListServiceClient> mockGrpcClient = new Mock <UserListService.UserListServiceClient>(MockBehavior.Strict);
            MutateUserListsRequest request = new MutateUserListsRequest
            {
                CustomerId = "customerId-1772061412",
                Operations = { },
            };
            MutateUserListsResponse expectedResponse = new MutateUserListsResponse();

            mockGrpcClient.Setup(x => x.MutateUserLists(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            UserListServiceClient   client   = new UserListServiceClientImpl(mockGrpcClient.Object, null);
            MutateUserListsResponse response = client.MutateUserLists(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void GetUserList2()
        {
            Mock <UserListService.UserListServiceClient> mockGrpcClient = new Mock <UserListService.UserListServiceClient>(MockBehavior.Strict);
            GetUserListRequest request = new GetUserListRequest
            {
                ResourceName = new UserListName("[CUSTOMER]", "[USER_LIST]").ToString(),
            };
            UserList expectedResponse = new UserList
            {
                ResourceName = "resourceName2625949903",
            };

            mockGrpcClient.Setup(x => x.GetUserList(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            UserListServiceClient client = new UserListServiceClientImpl(mockGrpcClient.Object, null);
            UserList response            = client.GetUserList(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task GetUserListAsync2()
        {
            Mock <UserListService.UserListServiceClient> mockGrpcClient = new Mock <UserListService.UserListServiceClient>(MockBehavior.Strict);
            GetUserListRequest request = new GetUserListRequest
            {
                ResourceName = new UserListName("[CUSTOMER]", "[USER_LIST]").ToString(),
            };
            UserList expectedResponse = new UserList
            {
                ResourceName = "resourceName2625949903",
            };

            mockGrpcClient.Setup(x => x.GetUserListAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <UserList>(Task.FromResult(expectedResponse), null, null, null, null));
            UserListServiceClient client = new UserListServiceClientImpl(mockGrpcClient.Object, null);
            UserList response            = await client.GetUserListAsync(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
예제 #8
0
        public void GetUserListRequestObject()
        {
            moq::Mock <UserListService.UserListServiceClient> mockGrpcClient = new moq::Mock <UserListService.UserListServiceClient>(moq::MockBehavior.Strict);
            GetUserListRequest request = new GetUserListRequest
            {
                ResourceNameAsUserListName = gagvr::UserListName.FromCustomerUserList("[CUSTOMER]", "[USER_LIST]"),
            };
            gagvr::UserList expectedResponse = new gagvr::UserList
            {
                ResourceNameAsUserListName = gagvr::UserListName.FromCustomerUserList("[CUSTOMER]", "[USER_LIST]"),
                Id                    = -6774108720365892680L,
                ReadOnly              = false,
                UserListName          = gagvr::UserListName.FromCustomerUserList("[CUSTOMER]", "[USER_LIST]"),
                Description           = "description2cf9da67",
                MembershipStatus      = gagve::UserListMembershipStatusEnum.Types.UserListMembershipStatus.Open,
                IntegrationCode       = "integration_codeb56c28f6",
                MembershipLifeSpan    = 8593891943371112615L,
                SizeForDisplay        = -3774093290138442712L,
                SizeRangeForDisplay   = gagve::UserListSizeRangeEnum.Types.UserListSizeRange.Unknown,
                SizeForSearch         = 7931927642168968409L,
                SizeRangeForSearch    = gagve::UserListSizeRangeEnum.Types.UserListSizeRange.OneHundredThousandToThreeHundredThousand,
                Type                  = gagve::UserListTypeEnum.Types.UserListType.CrmBased,
                ClosingReason         = gagve::UserListClosingReasonEnum.Types.UserListClosingReason.Unused,
                AccessReason          = gagve::AccessReasonEnum.Types.AccessReason.Affiliated,
                AccountUserListStatus = gagve::UserListAccessStatusEnum.Types.UserListAccessStatus.Disabled,
                EligibleForSearch     = false,
                EligibleForDisplay    = true,
                CrmBasedUserList      = new gagvc::CrmBasedUserListInfo(),
                SimilarUserList       = new gagvc::SimilarUserListInfo(),
                RuleBasedUserList     = new gagvc::RuleBasedUserListInfo(),
                LogicalUserList       = new gagvc::LogicalUserListInfo(),
                BasicUserList         = new gagvc::BasicUserListInfo(),
            };

            mockGrpcClient.Setup(x => x.GetUserList(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            UserListServiceClient client   = new UserListServiceClientImpl(mockGrpcClient.Object, null);
            gagvr::UserList       response = client.GetUserList(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task MutateUserListsAsync()
        {
            Mock <UserListService.UserListServiceClient> mockGrpcClient = new Mock <UserListService.UserListServiceClient>(MockBehavior.Strict);
            MutateUserListsRequest expectedRequest = new MutateUserListsRequest
            {
                CustomerId     = "customerId-1772061412",
                Operations     = { },
                PartialFailure = true,
                ValidateOnly   = false,
            };
            MutateUserListsResponse expectedResponse = new MutateUserListsResponse();

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

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