Ejemplo n.º 1
0
        public async stt::Task CreateWriteStreamRequestObjectAsync()
        {
            moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
            CreateWriteStreamRequest request = new CreateWriteStreamRequest
            {
                ParentAsTableName = TableName.FromProjectDatasetTable("[PROJECT]", "[DATASET]", "[TABLE]"),
                WriteStream       = new WriteStream(),
            };
            WriteStream expectedResponse = new WriteStream
            {
                WriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
                Type            = WriteStream.Types.Type.Buffered,
                CreateTime      = new wkt::Timestamp(),
                CommitTime      = new wkt::Timestamp(),
                TableSchema     = new TableSchema(),
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 2
0
        public async stt::Task BatchCommitWriteStreamsRequestObjectAsync()
        {
            moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
            BatchCommitWriteStreamsRequest request = new BatchCommitWriteStreamsRequest
            {
                Parent       = "parent7858e4d0",
                WriteStreams =
                {
                    "write_streams405973b2",
                },
            };
            BatchCommitWriteStreamsResponse expectedResponse = new BatchCommitWriteStreamsResponse
            {
                CommitTime   = new wkt::Timestamp(),
                StreamErrors = { new StorageError(), },
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void CreateWriteStream()
        {
            moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
            CreateWriteStreamRequest request = new CreateWriteStreamRequest
            {
                ParentAsTableName = TableName.FromProjectDatasetTable("[PROJECT]", "[DATASET]", "[TABLE]"),
                WriteStream       = new WriteStream(),
            };
            WriteStream expectedResponse = new WriteStream
            {
                WriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
                Type            = WriteStream.Types.Type.Buffered,
                CreateTime      = new wkt::Timestamp(),
                CommitTime      = new wkt::Timestamp(),
                TableSchema     = new TableSchema(),
                WriteMode       = WriteStream.Types.WriteMode.Unspecified,
            };

            mockGrpcClient.Setup(x => x.CreateWriteStream(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigQueryWriteClient client   = new BigQueryWriteClientImpl(mockGrpcClient.Object, null);
            WriteStream         response = client.CreateWriteStream(request.Parent, request.WriteStream);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 4
0
        public void FlushRowsResourceNames()
        {
            moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
            FlushRowsRequest request = new FlushRowsRequest
            {
                WriteStreamAsWriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
            };
            FlushRowsResponse expectedResponse = new FlushRowsResponse
            {
                Offset = -4389998161825790342L,
            };

            mockGrpcClient.Setup(x => x.FlushRows(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigQueryWriteClient client   = new BigQueryWriteClientImpl(mockGrpcClient.Object, null);
            FlushRowsResponse   response = client.FlushRows(request.WriteStreamAsWriteStreamName);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 5
0
        public void FinalizeWriteStreamResourceNames()
        {
            moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
            FinalizeWriteStreamRequest request = new FinalizeWriteStreamRequest
            {
                WriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
            };
            FinalizeWriteStreamResponse expectedResponse = new FinalizeWriteStreamResponse
            {
                RowCount = 9192966168813313852L,
            };

            mockGrpcClient.Setup(x => x.FinalizeWriteStream(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigQueryWriteClient         client   = new BigQueryWriteClientImpl(mockGrpcClient.Object, null);
            FinalizeWriteStreamResponse response = client.FinalizeWriteStream(request.WriteStreamName);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 6
0
        public void BatchCommitWriteStreams()
        {
            moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
            BatchCommitWriteStreamsRequest request = new BatchCommitWriteStreamsRequest
            {
                Parent = "parent7858e4d0",
            };
            BatchCommitWriteStreamsResponse expectedResponse = new BatchCommitWriteStreamsResponse
            {
                CommitTime   = new wkt::Timestamp(),
                StreamErrors = { new StorageError(), },
            };

            mockGrpcClient.Setup(x => x.BatchCommitWriteStreams(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigQueryWriteClient             client   = new BigQueryWriteClientImpl(mockGrpcClient.Object, null);
            BatchCommitWriteStreamsResponse response = client.BatchCommitWriteStreams(request.Parent);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 7
0
        public async stt::Task FlushRowsResourceNamesAsync()
        {
            moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
            FlushRowsRequest request = new FlushRowsRequest
            {
                WriteStreamAsWriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
            };
            FlushRowsResponse expectedResponse = new FlushRowsResponse
            {
                Offset = -4389998161825790342L,
            };

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

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            FlushRowsResponse responseCancellationToken = await client.FlushRowsAsync(request.WriteStreamAsWriteStreamName, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 8
0
        public async stt::Task FinalizeWriteStreamRequestObjectAsync()
        {
            moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
            FinalizeWriteStreamRequest request = new FinalizeWriteStreamRequest
            {
                WriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
            };
            FinalizeWriteStreamResponse expectedResponse = new FinalizeWriteStreamResponse
            {
                RowCount = 9192966168813313852L,
            };

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

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

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