Esempio n. 1
0
        public async stt::Task CreateAssessmentRequestObjectAsync()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            CreateAssessmentRequest request = new CreateAssessmentRequest
            {
                ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
                Assessment          = new Assessment(),
            };
            Assessment expectedResponse = new Assessment
            {
                AssessmentName  = AssessmentName.FromProjectAssessment("[PROJECT]", "[ASSESSMENT]"),
                Event           = new Event(),
                RiskAnalysis    = new RiskAnalysis(),
                TokenProperties = new TokenProperties(),
            };

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

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Assessment responseCancellationToken = await client.CreateAssessmentAsync(request, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 2
0
        public void UpdateKeyRequestObject()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            UpdateKeyRequest request = new UpdateKeyRequest
            {
                Key        = new Key(),
                UpdateMask = new wkt::FieldMask(),
            };
            Key expectedResponse = new Key
            {
                KeyName         = KeyName.FromProjectKey("[PROJECT]", "[KEY]"),
                DisplayName     = "display_name137f65c2",
                WebSettings     = new WebKeySettings(),
                AndroidSettings = new AndroidKeySettings(),
                IosSettings     = new IOSKeySettings(),
                Labels          =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                CreateTime = new wkt::Timestamp(),
            };

            mockGrpcClient.Setup(x => x.UpdateKey(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            RecaptchaEnterpriseServiceClient client = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);
            Key response = client.UpdateKey(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 3
0
        public async stt::Task UpdateKeyRequestObjectAsync()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            UpdateKeyRequest request = new UpdateKeyRequest
            {
                Key        = new Key(),
                UpdateMask = new wkt::FieldMask(),
            };
            Key expectedResponse = new Key
            {
                KeyName         = KeyName.FromProjectKey("[PROJECT]", "[KEY]"),
                DisplayName     = "display_name137f65c2",
                WebSettings     = new WebKeySettings(),
                AndroidSettings = new AndroidKeySettings(),
                IosSettings     = new IOSKeySettings(),
                Labels          =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                CreateTime = new wkt::Timestamp(),
            };

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

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Key responseCancellationToken = await client.UpdateKeyAsync(request, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 4
0
        public async stt::Task GetMetricsResourceNamesAsync()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            GetMetricsRequest request = new GetMetricsRequest
            {
                MetricsName = MetricsName.FromProjectKey("[PROJECT]", "[KEY]"),
            };
            Metrics expectedResponse = new Metrics
            {
                StartTime        = new wkt::Timestamp(),
                ScoreMetrics     = { new ScoreMetrics(), },
                ChallengeMetrics =
                {
                    new ChallengeMetrics(),
                },
                MetricsName = MetricsName.FromProjectKey("[PROJECT]", "[KEY]"),
            };

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

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Metrics responseCancellationToken = await client.GetMetricsAsync(request.MetricsName, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 5
0
        public void GetMetricsResourceNames()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            GetMetricsRequest request = new GetMetricsRequest
            {
                MetricsName = MetricsName.FromProjectKey("[PROJECT]", "[KEY]"),
            };
            Metrics expectedResponse = new Metrics
            {
                StartTime        = new wkt::Timestamp(),
                ScoreMetrics     = { new ScoreMetrics(), },
                ChallengeMetrics =
                {
                    new ChallengeMetrics(),
                },
                MetricsName = MetricsName.FromProjectKey("[PROJECT]", "[KEY]"),
            };

            mockGrpcClient.Setup(x => x.GetMetrics(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            RecaptchaEnterpriseServiceClient client = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);
            Metrics response = client.GetMetrics(request.MetricsName);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 6
0
        public async stt::Task AnnotateAssessmentRequestObjectAsync()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            AnnotateAssessmentRequest request = new AnnotateAssessmentRequest
            {
                AssessmentName = AssessmentName.FromProjectAssessment("[PROJECT]", "[ASSESSMENT]"),
                Annotation     = AnnotateAssessmentRequest.Types.Annotation.PasswordCorrect,
                Reasons        =
                {
                    AnnotateAssessmentRequest.Types.Reason.InitiatedTwoFactor,
                },
                HashedAccountId = proto::ByteString.CopyFromUtf8("hashed_account_id016ad986"),
            };
            AnnotateAssessmentResponse expectedResponse = new AnnotateAssessmentResponse {
            };

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

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            AnnotateAssessmentResponse responseCancellationToken = await client.AnnotateAssessmentAsync(request, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 7
0
        public void DeleteKeyRequestObject()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            DeleteKeyRequest request = new DeleteKeyRequest
            {
                KeyName = KeyName.FromProjectKey("[PROJECT]", "[KEY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty {
            };

            mockGrpcClient.Setup(x => x.DeleteKey(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            RecaptchaEnterpriseServiceClient client = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);

            client.DeleteKey(request);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 8
0
        public async stt::Task DeleteKeyRequestObjectAsync()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            DeleteKeyRequest request = new DeleteKeyRequest
            {
                KeyName = KeyName.FromProjectKey("[PROJECT]", "[KEY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty {
            };

            mockGrpcClient.Setup(x => x.DeleteKeyAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            RecaptchaEnterpriseServiceClient client = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);
            await client.DeleteKeyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            await client.DeleteKeyAsync(request, st::CancellationToken.None);

            mockGrpcClient.VerifyAll();
        }
Esempio n. 9
0
        public void AnnotateAssessmentResourceNames()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            AnnotateAssessmentRequest request = new AnnotateAssessmentRequest
            {
                AssessmentName = AssessmentName.FromProjectAssessment("[PROJECT]", "[ASSESSMENT]"),
                Annotation     = AnnotateAssessmentRequest.Types.Annotation.PasswordCorrect,
            };
            AnnotateAssessmentResponse expectedResponse = new AnnotateAssessmentResponse {
            };

            mockGrpcClient.Setup(x => x.AnnotateAssessment(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            RecaptchaEnterpriseServiceClient client   = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);
            AnnotateAssessmentResponse       response = client.AnnotateAssessment(request.AssessmentName, request.Annotation);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 10
0
        public void CreateAssessment()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            CreateAssessmentRequest request = new CreateAssessmentRequest
            {
                ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
                Assessment          = new Assessment(),
            };
            Assessment expectedResponse = new Assessment
            {
                AssessmentName  = AssessmentName.FromProjectAssessment("[PROJECT]", "[ASSESSMENT]"),
                Event           = new Event(),
                RiskAnalysis    = new RiskAnalysis(),
                TokenProperties = new TokenProperties(),
            };

            mockGrpcClient.Setup(x => x.CreateAssessment(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            RecaptchaEnterpriseServiceClient client = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);
            Assessment response = client.CreateAssessment(request.Parent, request.Assessment);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Esempio n. 11
0
        public void AnnotateAssessmentRequestObject()
        {
            moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
            AnnotateAssessmentRequest request = new AnnotateAssessmentRequest
            {
                AssessmentName = AssessmentName.FromProjectAssessment("[PROJECT]", "[ASSESSMENT]"),
                Annotation     = AnnotateAssessmentRequest.Types.Annotation.PasswordCorrect,
                Reasons        =
                {
                    AnnotateAssessmentRequest.Types.Reason.InitiatedTwoFactor,
                },
                HashedAccountId = proto::ByteString.CopyFromUtf8("hashed_account_id016ad986"),
            };
            AnnotateAssessmentResponse expectedResponse = new AnnotateAssessmentResponse {
            };

            mockGrpcClient.Setup(x => x.AnnotateAssessment(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            RecaptchaEnterpriseServiceClient client   = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);
            AnnotateAssessmentResponse       response = client.AnnotateAssessment(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }