public async stt::Task TestIamPermissionsResourceNamesAsync()
        {
            moq::Mock <Projects.ProjectsClient> mockGrpcClient = new moq::Mock <Projects.ProjectsClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            gciv::TestIamPermissionsRequest request = new gciv::TestIamPermissionsRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Permissions            =
                {
                    "permissions535a2741",
                },
            };
            gciv::TestIamPermissionsResponse expectedResponse = new gciv::TestIamPermissionsResponse
            {
                Permissions =
                {
                    "permissions535a2741",
                },
            };

            mockGrpcClient.Setup(x => x.TestIamPermissionsAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <gciv::TestIamPermissionsResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            ProjectsClient client = new ProjectsClientImpl(mockGrpcClient.Object, null);
            gciv::TestIamPermissionsResponse responseCallSettings = await client.TestIamPermissionsAsync(request.ResourceAsResourceName, request.Permissions, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            gciv::TestIamPermissionsResponse responseCancellationToken = await client.TestIamPermissionsAsync(request.ResourceAsResourceName, request.Permissions, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task SetIamPolicyResourceNamesAsync()
        {
            moq::Mock <Projects.ProjectsClient> mockGrpcClient = new moq::Mock <Projects.ProjectsClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            gciv::SetIamPolicyRequest request = new gciv::SetIamPolicyRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Policy = new gciv::Policy(),
            };
            gciv::Policy expectedResponse = new gciv::Policy
            {
                Version  = 271578922,
                Etag     = proto::ByteString.CopyFromUtf8("etage8ad7218"),
                Bindings =
                {
                    new gciv::Binding(),
                },
            };

            mockGrpcClient.Setup(x => x.SetIamPolicyAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <gciv::Policy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            ProjectsClient client = new ProjectsClientImpl(mockGrpcClient.Object, null);
            gciv::Policy   responseCallSettings = await client.SetIamPolicyAsync(request.ResourceAsResourceName, request.Policy, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            gciv::Policy responseCancellationToken = await client.SetIamPolicyAsync(request.ResourceAsResourceName, request.Policy, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void TestIamPermissionsResourceNames()
        {
            moq::Mock <Projects.ProjectsClient> mockGrpcClient = new moq::Mock <Projects.ProjectsClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            gciv::TestIamPermissionsRequest request = new gciv::TestIamPermissionsRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Permissions            =
                {
                    "permissions535a2741",
                },
            };
            gciv::TestIamPermissionsResponse expectedResponse = new gciv::TestIamPermissionsResponse
            {
                Permissions =
                {
                    "permissions535a2741",
                },
            };

            mockGrpcClient.Setup(x => x.TestIamPermissions(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            ProjectsClient client = new ProjectsClientImpl(mockGrpcClient.Object, null);
            gciv::TestIamPermissionsResponse response = client.TestIamPermissions(request.ResourceAsResourceName, request.Permissions);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void SetIamPolicyResourceNames()
        {
            moq::Mock <Projects.ProjectsClient> mockGrpcClient = new moq::Mock <Projects.ProjectsClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            gciv::SetIamPolicyRequest request = new gciv::SetIamPolicyRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Policy = new gciv::Policy(),
            };
            gciv::Policy expectedResponse = new gciv::Policy
            {
                Version  = 271578922,
                Etag     = proto::ByteString.CopyFromUtf8("etage8ad7218"),
                Bindings =
                {
                    new gciv::Binding(),
                },
            };

            mockGrpcClient.Setup(x => x.SetIamPolicy(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            ProjectsClient client   = new ProjectsClientImpl(mockGrpcClient.Object, null);
            gciv::Policy   response = client.SetIamPolicy(request.ResourceAsResourceName, request.Policy);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task GetProjectRequestObjectAsync()
        {
            moq::Mock <Projects.ProjectsClient> mockGrpcClient = new moq::Mock <Projects.ProjectsClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetProjectRequest request = new GetProjectRequest
            {
                ProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
            };
            Project expectedResponse = new Project
            {
                ProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
                Parent      = "parent7858e4d0",
                ProjectId   = "project_id43ad98b0",
                State       = Project.Types.State.Unspecified,
                DisplayName = "display_name137f65c2",
                CreateTime  = new wkt::Timestamp(),
                UpdateTime  = new wkt::Timestamp(),
                DeleteTime  = new wkt::Timestamp(),
                Etag        = "etage8ad7218",
                Labels      =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Beispiel #6
0
        public async stt::Task GetRequestObjectAsync()
        {
            moq::Mock <Projects.ProjectsClient> mockGrpcClient = new moq::Mock <Projects.ProjectsClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClientForGlobalOperations()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetProjectRequest request = new GetProjectRequest
            {
                Project = "projectaa6ff846",
            };
            Project expectedResponse = new Project
            {
                Id   = 11672635353343658936UL,
                Kind = "kindf7aa39d9",
                Name = "name1c9368b0",
                CreationTimestamp      = "creation_timestamp235e59a1",
                Quotas                 = { new Quota(), },
                CommonInstanceMetadata = new Metadata(),
                XpnProjectStatus       = "xpn_project_status547f92f1",
                DefaultServiceAccount  = "default_service_accountdf12b0f2",
                UsageExportLocation    = new UsageExportLocation(),
                Description            = "description2cf9da67",
                SelfLink               = "self_link7e87f12d",
                EnabledFeatures        =
                {
                    "enabled_featuresf1f398e0",
                },
                DefaultNetworkTier = "default_network_tier69d9d1a9",
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void GetProjectResourceNames()
        {
            moq::Mock <Projects.ProjectsClient> mockGrpcClient = new moq::Mock <Projects.ProjectsClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetProjectRequest request = new GetProjectRequest
            {
                ProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
            };
            Project expectedResponse = new Project
            {
                ProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
                Parent      = "parent7858e4d0",
                ProjectId   = "project_id43ad98b0",
                State       = Project.Types.State.Unspecified,
                DisplayName = "display_name137f65c2",
                CreateTime  = new wkt::Timestamp(),
                UpdateTime  = new wkt::Timestamp(),
                DeleteTime  = new wkt::Timestamp(),
                Etag        = "etage8ad7218",
                Labels      =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
            };

            mockGrpcClient.Setup(x => x.GetProject(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            ProjectsClient client   = new ProjectsClientImpl(mockGrpcClient.Object, null);
            Project        response = client.GetProject(request.ProjectName);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Beispiel #8
0
        public void GetRequestObject()
        {
            moq::Mock <Projects.ProjectsClient> mockGrpcClient = new moq::Mock <Projects.ProjectsClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClientForGlobalOperations()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetProjectRequest request = new GetProjectRequest
            {
                Project = "projectaa6ff846",
            };
            Project expectedResponse = new Project
            {
                Id   = 11672635353343658936UL,
                Kind = "kindf7aa39d9",
                Name = "name1c9368b0",
                CreationTimestamp      = "creation_timestamp235e59a1",
                Quotas                 = { new Quota(), },
                CommonInstanceMetadata = new Metadata(),
                XpnProjectStatus       = Project.Types.XpnProjectStatus.Host,
                DefaultServiceAccount  = "default_service_accountdf12b0f2",
                UsageExportLocation    = new UsageExportLocation(),
                Description            = "description2cf9da67",
                SelfLink               = "self_link7e87f12d",
                EnabledFeatures        =
                {
                    "enabled_featuresf1f398e0",
                },
                DefaultNetworkTier = Project.Types.DefaultNetworkTier.Premium,
            };

            mockGrpcClient.Setup(x => x.Get(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            ProjectsClient client   = new ProjectsClientImpl(mockGrpcClient.Object, null);
            Project        response = client.Get(request);

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