public async Task PatchDocumentsAsync_ShouldSucceed()
        {
            var postResponse = await _docClient.PostDocumentsAsync(_testCollection,
                                                                   new[] {
                new { Value = 1, Name = "test1" },
                new { Value = 2, Name = "test2" },
                new { Value = 3, Name = "test3" }
            }, new PostDocumentsQuery
            {
                ReturnNew   = true,
                WaitForSync = true
            });

            var response = await _docClient.PatchDocumentsAsync <object, PatchDocumentsMockModel>(_testCollection,
                                                                                                  new[] {
                new { postResponse[0]._key, Name = "test5" },
                new { postResponse[1]._key, Name = "test4" }
            }, new PatchDocumentsQuery
            {
                ReturnNew   = true,
                WaitForSync = true,
                ReturnOld   = true
            });

            Assert.Equal(2, response.Count);
            Assert.NotEqual(postResponse[0]._rev, response[0]._rev);
            Assert.NotEqual(postResponse[0].New.Name, response[0].New.Name);
            Assert.Equal(postResponse[0].New.Name, response[0].Old.Name);
            Assert.Equal(postResponse[0]._rev, response[0]._oldRev);
        }
        public async Task PatchDocumentsAsync_ShouldUseQueryParameters_WhenProvided()
        {
            var mockTransport = new Mock <IApiClientTransport>();

            var mockResponse = new Mock <IApiClientResponse>();

            var mockResponseContent = new Mock <IApiClientResponseContent>();

            mockResponse.Setup(x => x.Content)
            .Returns(mockResponseContent.Object);

            mockResponse.Setup(x => x.IsSuccessStatusCode)
            .Returns(true);

            string requestUri = null;

            mockTransport.Setup(x => x.PatchAsync(It.IsAny <string>(), It.IsAny <byte[]>()))
            .Returns((string uri, byte[] content) =>
            {
                requestUri = uri;
                return(Task.FromResult(mockResponse.Object));
            });

            var client = new DocumentApiClient(mockTransport.Object);

            await client.PatchDocumentsAsync <object, object>(
                "mycollection",
                new[]
            {
                new { Value = 1, Name = "test1" },
                new { Value = 2, Name = "test2" },
                new { Value = 3, Name = "test3" }
            },
                new PatchDocumentsQuery
            {
                IgnoreRevs   = true,
                ReturnOld    = true,
                Silent       = true,
                WaitForSync  = true,
                KeepNull     = true,
                MergeObjects = true,
                ReturnNew    = true
            });

            Assert.NotNull(requestUri);
            Assert.Contains("ignoreRevs=true", requestUri);
            Assert.Contains("returnOld=true", requestUri);
            Assert.Contains("silent=true", requestUri);
            Assert.Contains("waitForSync=true", requestUri);
            Assert.Contains("keepNull=true", requestUri);
            Assert.Contains("mergeObjects=true", requestUri);
            Assert.Contains("returnNew=true", requestUri);
        }