public void BeginTransactionRequestObject()
        {
            moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict);
            BeginTransactionRequest request = new BeginTransactionRequest
            {
                Database = "projects/test/databases/databased8eee011",
                Options  = new TransactionOptions(),
            };
            BeginTransactionResponse expectedResponse = new BeginTransactionResponse
            {
                Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"),
            };

            mockGrpcClient.Setup(x => x.BeginTransaction(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            FirestoreClient          client   = new FirestoreClientImpl(mockGrpcClient.Object, null);
            BeginTransactionResponse response = client.BeginTransaction(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task BeginTransactionAsync()
        {
            Mock <Firestore.FirestoreClient> mockGrpcClient  = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict);
            BeginTransactionRequest          expectedRequest = new BeginTransactionRequest
            {
                Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(),
            };
            BeginTransactionResponse expectedResponse = new BeginTransactionResponse
            {
                Transaction = ByteString.CopyFromUtf8("-34"),
            };

            mockGrpcClient.Setup(x => x.BeginTransactionAsync(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <BeginTransactionResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            FirestoreClient          client            = new FirestoreClientImpl(mockGrpcClient.Object, null);
            string                   formattedDatabase = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString();
            BeginTransactionResponse response          = await client.BeginTransactionAsync(formattedDatabase);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task UpdateDocumentAsync2()
        {
            Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict);
            UpdateDocumentRequest            request        = new UpdateDocumentRequest
            {
                Document   = new Document(),
                UpdateMask = new DocumentMask(),
            };
            Document expectedResponse = new Document
            {
                Name = "name3373707",
            };

            mockGrpcClient.Setup(x => x.UpdateDocumentAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <Document>(Task.FromResult(expectedResponse), null, null, null, null));
            FirestoreClient client   = new FirestoreClientImpl(mockGrpcClient.Object, null);
            Document        response = await client.UpdateDocumentAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void UpdateDocument2()
        {
            Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict);
            UpdateDocumentRequest            request        = new UpdateDocumentRequest
            {
                Document   = new Document(),
                UpdateMask = new DocumentMask(),
            };
            Document expectedResponse = new Document
            {
                Name = "name3373707",
            };

            mockGrpcClient.Setup(x => x.UpdateDocument(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            FirestoreClient client   = new FirestoreClientImpl(mockGrpcClient.Object, null);
            Document        response = client.UpdateDocument(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
示例#5
0
        public void Commit()
        {
            moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict);
            CommitRequest request = new CommitRequest
            {
                Database = "projects/test/databases/databased8eee011",
                Writes   = { new Write(), },
            };
            CommitResponse expectedResponse = new CommitResponse
            {
                WriteResults = { new WriteResult(), },
                CommitTime   = new wkt::Timestamp(),
            };

            mockGrpcClient.Setup(x => x.Commit(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            FirestoreClient client   = new FirestoreClientImpl(mockGrpcClient.Object, null);
            CommitResponse  response = client.Commit(request.Database, request.Writes);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
示例#6
0
        public async stt::Task BeginTransactionAsync()
        {
            moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict);
            BeginTransactionRequest request = new BeginTransactionRequest
            {
                Database = "projects/test/databases/databased8eee011",
            };
            BeginTransactionResponse expectedResponse = new BeginTransactionResponse
            {
                Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"),
            };

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

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            BeginTransactionResponse responseCancellationToken = await client.BeginTransactionAsync(request.Database, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public void CreateDocument()
        {
            Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict);
            CreateDocumentRequest            request        = new CreateDocumentRequest
            {
                Parent       = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(),
                CollectionId = "collectionId-821242276",
                DocumentId   = "documentId506676927",
                Document     = new Document(),
            };
            Document expectedResponse = new Document
            {
                Name = "name3373707",
            };

            mockGrpcClient.Setup(x => x.CreateDocument(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            FirestoreClient client   = new FirestoreClientImpl(mockGrpcClient.Object, null);
            Document        response = client.CreateDocument(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
示例#8
0
        public async stt::Task CommitAsync()
        {
            moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict);
            CommitRequest request = new CommitRequest
            {
                Database = "projects/test/databases/databased8eee011",
                Writes   = { new Write(), },
            };
            CommitResponse expectedResponse = new CommitResponse
            {
                WriteResults = { new WriteResult(), },
                CommitTime   = new wkt::Timestamp(),
            };

            mockGrpcClient.Setup(x => x.CommitAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <CommitResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null);
            CommitResponse  responseCallSettings = await client.CommitAsync(request.Database, request.Writes, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            CommitResponse responseCancellationToken = await client.CommitAsync(request.Database, request.Writes, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
示例#9
0
 public void GetDatabaseResourceName_Invalid(string resourceName)
 {
     Assert.Throws <ArgumentException>(() => FirestoreClientImpl.GetDatabaseResourceName(resourceName));
 }
示例#10
0
 public void GetDatabaseResourceName_Valid(string resourceName, string expectedDatabaseName)
 {
     Assert.Equal(expectedDatabaseName, FirestoreClientImpl.GetDatabaseResourceName(resourceName));
 }