Пример #1
0
        public async Task CreateCompanyAsync()
        {
            Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
            CreateCompanyRequest expectedRequest = new CreateCompanyRequest
            {
                ParentAsTenantOrProjectNameOneof = TenantOrProjectNameOneof.From(new TenantName("[PROJECT]", "[TENANT]")),
                Company = new Company(),
            };
            Company expectedResponse = new Company
            {
                CompanyNameOneof    = CompanyNameOneof.From(new CompanyOldName("[PROJECT]", "[COMPANY]")),
                DisplayName         = "displayName1615086568",
                ExternalId          = "externalId-1153075697",
                HeadquartersAddress = "headquartersAddress-1879520036",
                HiringAgency        = false,
                EeoText             = "eeoText-1652097123",
                WebsiteUri          = "websiteUri-2118185016",
                CareerSiteUri       = "careerSiteUri1223331861",
                ImageUri            = "imageUri-877823864",
                Suspended           = false,
            };

            mockGrpcClient.Setup(x => x.CreateCompanyAsync(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <Company>(Task.FromResult(expectedResponse), null, null, null, null));
            CompanyServiceClient     client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            TenantOrProjectNameOneof parent = TenantOrProjectNameOneof.From(new TenantName("[PROJECT]", "[TENANT]"));
            Company company  = new Company();
            Company response = await client.CreateCompanyAsync(parent, company);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void UpdateCompany()
        {
            moq::Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new moq::Mock <CompanyService.CompanyServiceClient>(moq::MockBehavior.Strict);
            UpdateCompanyRequest request = new UpdateCompanyRequest
            {
                Company = new Company(),
            };
            Company expectedResponse = new Company
            {
                CompanyName         = CompanyName.FromProjectTenantCompany("[PROJECT]", "[TENANT]", "[COMPANY]"),
                DisplayName         = "display_name137f65c2",
                ExternalId          = "external_id9442680e",
                Size                = CompanySize.Mini,
                HeadquartersAddress = "headquarters_address64cd7eb7",
                HiringAgency        = true,
                EeoText             = "eeo_text70a1a576",
                WebsiteUri          = "website_urid0c5dfce",
                CareerSiteUri       = "career_site_uri62d45b74",
                ImageUri            = "image_urieba3b1bc",
                KeywordSearchableJobCustomAttributes =
                {
                    "keyword_searchable_job_custom_attributese72ec77c",
                },
                DerivedInfo = new Company.Types.DerivedInfo(),
                Suspended   = true,
            };

            mockGrpcClient.Setup(x => x.UpdateCompany(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            Company response            = client.UpdateCompany(request.Company);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Пример #3
0
        public void UpdateCompany2()
        {
            Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
            UpdateCompanyRequest request = new UpdateCompanyRequest
            {
                Company = new Company(),
            };
            Company expectedResponse = new Company
            {
                CompanyNameOneof    = CompanyNameOneof.From(new CompanyOldName("[PROJECT]", "[COMPANY]")),
                DisplayName         = "displayName1615086568",
                ExternalId          = "externalId-1153075697",
                HeadquartersAddress = "headquartersAddress-1879520036",
                HiringAgency        = false,
                EeoText             = "eeoText-1652097123",
                WebsiteUri          = "websiteUri-2118185016",
                CareerSiteUri       = "careerSiteUri1223331861",
                ImageUri            = "imageUri-877823864",
                Suspended           = false,
            };

            mockGrpcClient.Setup(x => x.UpdateCompany(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            Company response            = client.UpdateCompany(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Пример #4
0
        public async Task UpdateCompanyAsync2()
        {
            Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
            UpdateCompanyRequest request = new UpdateCompanyRequest
            {
                Company = new Company(),
            };
            Company expectedResponse = new Company
            {
                Name                = "name3373707",
                DisplayName         = "displayName1615086568",
                ExternalId          = "externalId-1153075697",
                HeadquartersAddress = "headquartersAddress-1879520036",
                HiringAgency        = false,
                EeoText             = "eeoText-1652097123",
                WebsiteUri          = "websiteUri-2118185016",
                CareerSiteUri       = "careerSiteUri1223331861",
                ImageUri            = "imageUri-877823864",
                Suspended           = false,
            };

            mockGrpcClient.Setup(x => x.UpdateCompanyAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <Company>(Task.FromResult(expectedResponse), null, null, null, null));
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            Company response            = await client.UpdateCompanyAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Пример #5
0
        public void CreateCompany()
        {
            Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
            CreateCompanyRequest expectedRequest = new CreateCompanyRequest
            {
                Parent  = new ProjectName("[PROJECT]").ToString(),
                Company = new Company(),
            };
            Company expectedResponse = new Company
            {
                Name                = "name3373707",
                DisplayName         = "displayName1615086568",
                ExternalId          = "externalId-1153075697",
                HeadquartersAddress = "headquartersAddress-1879520036",
                HiringAgency        = false,
                EeoText             = "eeoText-1652097123",
                WebsiteUri          = "websiteUri-2118185016",
                CareerSiteUri       = "careerSiteUri1223331861",
                ImageUri            = "imageUri-877823864",
                Suspended           = false,
            };

            mockGrpcClient.Setup(x => x.CreateCompany(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            string  formattedParent     = new ProjectName("[PROJECT]").ToString();
            Company company             = new Company();
            Company response            = client.CreateCompany(formattedParent, company);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void DeleteCompanyResourceNames()
        {
            moq::Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new moq::Mock <CompanyService.CompanyServiceClient>(moq::MockBehavior.Strict);
            DeleteCompanyRequest request = new DeleteCompanyRequest
            {
                CompanyName = CompanyName.FromProjectTenantCompany("[PROJECT]", "[TENANT]", "[COMPANY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty {
            };

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

            client.DeleteCompany(request.CompanyName);
            mockGrpcClient.VerifyAll();
        }
Пример #7
0
        public async Task DeleteCompanyAsync2()
        {
            Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
            DeleteCompanyRequest request = new DeleteCompanyRequest
            {
                CompanyNameOneof = CompanyNameOneof.From(new CompanyOldName("[PROJECT]", "[COMPANY]")),
            };
            Empty expectedResponse = new Empty();

            mockGrpcClient.Setup(x => x.DeleteCompanyAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);
            await client.DeleteCompanyAsync(request);

            mockGrpcClient.VerifyAll();
        }
Пример #8
0
        public void DeleteCompany2()
        {
            Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new Mock <CompanyService.CompanyServiceClient>(MockBehavior.Strict);
            DeleteCompanyRequest request = new DeleteCompanyRequest
            {
                CompanyNameOneof = CompanyNameOneof.From(new CompanyOldName("[PROJECT]", "[COMPANY]")),
            };
            Empty expectedResponse = new Empty();

            mockGrpcClient.Setup(x => x.DeleteCompany(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            CompanyServiceClient client = new CompanyServiceClientImpl(mockGrpcClient.Object, null);

            client.DeleteCompany(request);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task DeleteCompanyResourceNamesAsync()
        {
            moq::Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new moq::Mock <CompanyService.CompanyServiceClient>(moq::MockBehavior.Strict);
            DeleteCompanyRequest request = new DeleteCompanyRequest
            {
                CompanyName = CompanyName.FromProjectTenantCompany("[PROJECT]", "[TENANT]", "[COMPANY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty {
            };

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

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

            mockGrpcClient.VerifyAll();
        }
        public async stt::Task CreateCompanyRequestObjectAsync()
        {
            moq::Mock <CompanyService.CompanyServiceClient> mockGrpcClient = new moq::Mock <CompanyService.CompanyServiceClient>(moq::MockBehavior.Strict);
            CreateCompanyRequest request = new CreateCompanyRequest
            {
                ParentAsTenantName = TenantName.FromProjectTenant("[PROJECT]", "[TENANT]"),
                Company            = new Company(),
            };
            Company expectedResponse = new Company
            {
                CompanyName         = CompanyName.FromProjectTenantCompany("[PROJECT]", "[TENANT]", "[COMPANY]"),
                DisplayName         = "display_name137f65c2",
                ExternalId          = "external_id9442680e",
                Size                = CompanySize.Mini,
                HeadquartersAddress = "headquarters_address64cd7eb7",
                HiringAgency        = true,
                EeoText             = "eeo_text70a1a576",
                WebsiteUri          = "website_urid0c5dfce",
                CareerSiteUri       = "career_site_uri62d45b74",
                ImageUri            = "image_urieba3b1bc",
                KeywordSearchableJobCustomAttributes =
                {
                    "keyword_searchable_job_custom_attributese72ec77c",
                },
                DerivedInfo = new Company.Types.DerivedInfo(),
                Suspended   = true,
            };

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

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

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