public async stt::Task ReadModifyWriteRow2ResourceNamesAsync()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            ReadModifyWriteRowRequest           request        = new ReadModifyWriteRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                Rules  =
                {
                    new ReadModifyWriteRule(),
                },
                AppProfileId = "app_profile_id57fb0442",
            };
            ReadModifyWriteRowResponse expectedResponse = new ReadModifyWriteRowResponse {
                Row = new Row(),
            };

            mockGrpcClient.Setup(x => x.ReadModifyWriteRowAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <ReadModifyWriteRowResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            BigtableClient             client = new BigtableClientImpl(mockGrpcClient.Object, null);
            ReadModifyWriteRowResponse responseCallSettings = await client.ReadModifyWriteRowAsync(request.TableNameAsTableName, request.RowKey, request.Rules, request.AppProfileId, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            ReadModifyWriteRowResponse responseCancellationToken = await client.ReadModifyWriteRowAsync(request.TableNameAsTableName, request.RowKey, request.Rules, request.AppProfileId, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task CheckAndMutateRow2Async()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            CheckAndMutateRowRequest            request        = new CheckAndMutateRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey          = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                TrueMutations   = { new Mutation(), },
                FalseMutations  = { new Mutation(), },
                PredicateFilter = new RowFilter(),
                AppProfileId    = "app_profile_id57fb0442",
            };
            CheckAndMutateRowResponse expectedResponse = new CheckAndMutateRowResponse
            {
                PredicateMatched = true,
            };

            mockGrpcClient.Setup(x => x.CheckAndMutateRowAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <CheckAndMutateRowResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            BigtableClient            client = new BigtableClientImpl(mockGrpcClient.Object, null);
            CheckAndMutateRowResponse responseCallSettings = await client.CheckAndMutateRowAsync(request.TableName, request.RowKey, request.PredicateFilter, request.TrueMutations, request.FalseMutations, request.AppProfileId, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            CheckAndMutateRowResponse responseCancellationToken = await client.CheckAndMutateRowAsync(request.TableName, request.RowKey, request.PredicateFilter, request.TrueMutations, request.FalseMutations, request.AppProfileId, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 3
0
        public async Task CheckAndMutateRow_AppProfileId_From_Client()
        {
            var appProfileIdOnClient = "csharp";
            var request = new CheckAndMutateRowRequest
            {
                TableNameAsTableName = new TableName("project", "instance", "table"),
                RowKey         = ByteString.CopyFromUtf8("abc"),
                FalseMutations = { new Mutation() },
                TrueMutations  = { new Mutation() }
            };
            var request2 = new CheckAndMutateRowRequest(request);
            Mock <BigtableServiceApiClient> mockGrpcClient =
                new Mock <BigtableServiceApiClient>(MockBehavior.Strict);

            mockGrpcClient
            .Setup(x => x.CheckAndMutateRow(request, It.IsAny <CallSettings>()))
            .Returns(new CheckAndMutateRowResponse());
            mockGrpcClient
            .Setup(x => x.CheckAndMutateRowAsync(request, It.IsAny <CallSettings>()))
            .ReturnsAsync(new CheckAndMutateRowResponse());
            BigtableClient client = new BigtableClientImpl(mockGrpcClient.Object, appProfileIdOnClient);

            client.CheckAndMutateRow(request);
            await client.CheckAndMutateRowAsync(request2);

            Assert.Equal(appProfileIdOnClient, request.AppProfileId);
            Assert.Equal(appProfileIdOnClient, request2.AppProfileId);
        }
        public void MutateRow1()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            MutateRowRequest request = new MutateRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey    = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                Mutations = { new Mutation(), },
            };
            MutateRowResponse expectedResponse = new MutateRowResponse {
            };

            mockGrpcClient.Setup(x => x.MutateRow(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigtableClient    client   = new BigtableClientImpl(mockGrpcClient.Object, null);
            MutateRowResponse response = client.MutateRow(request.TableName, request.RowKey, request.Mutations);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task MutateRow1Async()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            MutateRowRequest request = new MutateRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey    = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                Mutations = { new Mutation(), },
            };
            MutateRowResponse expectedResponse = new MutateRowResponse {
            };

            mockGrpcClient.Setup(x => x.MutateRowAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <MutateRowResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            BigtableClient    client = new BigtableClientImpl(mockGrpcClient.Object, null);
            MutateRowResponse responseCallSettings = await client.MutateRowAsync(request.TableName, request.RowKey, request.Mutations, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            MutateRowResponse responseCancellationToken = await client.MutateRowAsync(request.TableName, request.RowKey, request.Mutations, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void CheckAndMutateRow1ResourceNames()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            CheckAndMutateRowRequest            request        = new CheckAndMutateRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey          = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                TrueMutations   = { new Mutation(), },
                FalseMutations  = { new Mutation(), },
                PredicateFilter = new RowFilter(),
            };
            CheckAndMutateRowResponse expectedResponse = new CheckAndMutateRowResponse
            {
                PredicateMatched = true,
            };

            mockGrpcClient.Setup(x => x.CheckAndMutateRow(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigtableClient            client   = new BigtableClientImpl(mockGrpcClient.Object, null);
            CheckAndMutateRowResponse response = client.CheckAndMutateRow(request.TableNameAsTableName, request.RowKey, request.PredicateFilter, request.TrueMutations, request.FalseMutations);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void ReadModifyWriteRow2ResourceNames()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            ReadModifyWriteRowRequest           request        = new ReadModifyWriteRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                Rules  =
                {
                    new ReadModifyWriteRule(),
                },
                AppProfileId = "app_profile_id57fb0442",
            };
            ReadModifyWriteRowResponse expectedResponse = new ReadModifyWriteRowResponse {
                Row = new Row(),
            };

            mockGrpcClient.Setup(x => x.ReadModifyWriteRow(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigtableClient             client   = new BigtableClientImpl(mockGrpcClient.Object, null);
            ReadModifyWriteRowResponse response = client.ReadModifyWriteRow(request.TableNameAsTableName, request.RowKey, request.Rules, request.AppProfileId);

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