public async Task StandByFeedIterator_WithMaxItemCount()
{
await this.CreateRandomItems(2, randomPartitionKey : true);
ContainerCore itemsCore = (ContainerCore)this.Container;
FeedIterator feedIterator = itemsCore.GetStandByFeedIterator(maxItemCount: 1, requestOptions: new ChangeFeedRequestOptions()
{
StartTime = DateTime.MinValue
});
while (feedIterator.HasMoreResults)
{
using (ResponseMessage responseMessage =
await feedIterator.ReadNextAsync(this.cancellationToken))
{
if (responseMessage.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data;
if (response.Count > 0)
{
Assert.AreEqual(1, response.Count);
return;
}
}
}
}
Assert.Fail("Found no batch with size 1");
}
public async Task TestInitialize()
{
await base.TestInit();
string PartitionKey = "/status";
ContainerResponse response = await this.database.CreateContainerAsync(
new CosmosContainerProperties(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey),
cancellationToken : this.cancellationToken);
Assert.IsNotNull(response);
this.container = response;
this.jsonSerializer = new CosmosJsonSerializerCore();
}
public void ValidateJson()
{
CosmosJsonSerializerCore cosmosDefaultJsonSerializer = new CosmosJsonSerializerCore();
using (Stream stream = cosmosDefaultJsonSerializer.ToStream <ToDoActivity>(this.toDoActivity))
{
Assert.IsNotNull(stream);
using (StreamReader reader = new StreamReader(stream))
{
string responseAsString = reader.ReadToEnd();
Assert.IsNotNull(responseAsString);
Assert.AreEqual(this.toDoActivityJson, responseAsString);
}
}
}
public async Task StandByFeedIterator_NoFetchNext()
{
var pkRanges = await this.Container.ClientContext.DocumentClient.ReadPartitionKeyRangeFeedAsync(this.Container.LinkUri);
int expected = 25;
int iterations = 0;
await this.CreateRandomItems(expected, randomPartitionKey : true);
ContainerCore itemsCore = (ContainerCore)this.Container;
string continuationToken = null;
int count = 0;
while (true)
{
ChangeFeedRequestOptions requestOptions = new ChangeFeedRequestOptions()
{
StartTime = DateTime.MinValue
};
FeedIterator feedIterator = itemsCore.GetStandByFeedIterator(continuationToken, requestOptions: requestOptions);
using (ResponseMessage responseMessage =
await feedIterator.ReadNextAsync(this.cancellationToken))
{
continuationToken = responseMessage.Headers.Continuation;
if (responseMessage.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data;
count += response.Count;
}
}
if (count > expected)
{
Assert.Fail($"{count} does not equal {expected}");
}
if (count.Equals(expected))
{
break;
}
if (iterations++ > pkRanges.Count)
{
Assert.Fail("Feed does not contain all elements even after looping through PK ranges. Either the continuation is not moving forward or there is some state problem.");
}
}
}
public void ValidateSerializer()
{
CosmosJsonSerializerCore cosmosDefaultJsonSerializer = new CosmosJsonSerializerCore();
using (Stream stream = cosmosDefaultJsonSerializer.ToStream <ToDoActivity>(this.toDoActivity))
{
Assert.IsNotNull(stream);
ToDoActivity result = cosmosDefaultJsonSerializer.FromStream <ToDoActivity>(stream);
Assert.IsNotNull(result);
Assert.AreEqual(this.toDoActivity.id, result.id);
Assert.AreEqual(this.toDoActivity.taskNum, result.taskNum);
Assert.AreEqual(this.toDoActivity.cost, result.cost);
Assert.AreEqual(this.toDoActivity.description, result.description);
Assert.AreEqual(this.toDoActivity.status, result.status);
}
}
public async Task StreamIteratorTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
ContainerResponse containerResponse = await this.cosmosDatabase.CreateContainerAsync(containerName, partitionKeyPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
containerName = Guid.NewGuid().ToString();
containerResponse = await this.cosmosDatabase.CreateContainerAsync(containerName, partitionKeyPath);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
HashSet <string> containerIds = new HashSet <string>();
FeedIterator resultSet = this.cosmosDatabase.GetContainerQueryStreamIterator(
requestOptions: new QueryRequestOptions()
{
MaxItemCount = 1
});
while (resultSet.HasMoreResults)
{
using (ResponseMessage message = await resultSet.ReadNextAsync())
{
Assert.AreEqual(HttpStatusCode.OK, message.StatusCode);
CosmosJsonSerializerCore defaultJsonSerializer = new CosmosJsonSerializerCore();
dynamic containers = defaultJsonSerializer.FromStream <dynamic>(message.Content).DocumentCollections;
foreach (dynamic container in containers)
{
string id = container.id.ToString();
containerIds.Add(id);
}
}
}
Assert.IsTrue(containerIds.Count > 0, "The iterator did not find any containers.");
Assert.IsTrue(containerIds.Contains(containerName), "The iterator did not find the created container");
containerResponse = await containerResponse.Container.DeleteContainerAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task CosmosConflictsStreamIteratorBuildsSettings()
{
string conflictResponsePayload = @"{ 'Data':[{
id: 'Conflict1',
operationType: 'Replace',
resourceType: 'trigger'
}]}";
CosmosClient mockClient = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.WithConnectionModeDirect());
CosmosContainer container = mockClient.GetContainer("database", "container");
FeedIterator feedIterator = container.GetConflicts().GetConflictsStreamIterator();
TestHandler testHandler = new TestHandler((request, cancellationToken) =>
{
Assert.AreEqual(OperationType.ReadFeed, request.OperationType);
Assert.AreEqual(ResourceType.Conflict, request.ResourceType);
CosmosResponseMessage handlerResponse = TestHandler.ReturnSuccess().Result;
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.Write(conflictResponsePayload);
writer.Flush();
stream.Position = 0;
handlerResponse.Content = stream;
return(Task.FromResult(handlerResponse));
});
mockClient.RequestHandler.InnerHandler = testHandler;
CosmosResponseMessage streamResponse = await feedIterator.FetchNextSetAsync();
Collection <CosmosConflictSettings> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <CosmosConflictSettings> >(streamResponse.Content).Data;
Assert.AreEqual(1, response.Count());
CosmosConflictSettings responseSettings = response.FirstOrDefault();
Assert.IsNotNull(responseSettings);
Assert.AreEqual("Conflict1", responseSettings.Id);
Assert.AreEqual(Cosmos.OperationKind.Replace, responseSettings.OperationKind);
Assert.AreEqual(typeof(CosmosTriggerSettings), responseSettings.ResourceType);
}
public async Task TestInitialize()
{
this.cancellationTokenSource = new CancellationTokenSource();
this.cancellationToken = this.cancellationTokenSource.Token;
this.cosmosClient = TestCommon.CreateCosmosClient();
this.database = await this.cosmosClient.CreateDatabaseAsync(Guid.NewGuid().ToString(),
cancellationToken : this.cancellationToken);
this.documentClient = TestCommon.CreateClient(true, defaultConsistencyLevel: Documents.ConsistencyLevel.Session);
string PartitionKey = "/partitionKey";
ContainerResponse response = await this.database.CreateContainerAsync(
new ContainerProperties(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey),
cancellationToken : this.cancellationToken);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Container);
Assert.IsNotNull(response.Resource);
this.Container = (ContainerCore)response;
this.jsonSerializer = new CosmosJsonSerializerCore();
}
private static CosmosClientContext GetMockedClientContext(
Func <CosmosRequestMessage, CancellationToken, Task <CosmosResponseMessage> > handlerFunc)
{
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient();
Mock <PartitionRoutingHelper> partitionRoutingHelperMock = MockCosmosUtil.GetPartitionRoutingHelperMock("0");
PartitionKeyRangeHandler partitionKeyRangeHandler = new PartitionKeyRangeHandler(client, partitionRoutingHelperMock.Object);
TestHandler testHandler = new TestHandler(handlerFunc);
partitionKeyRangeHandler.InnerHandler = testHandler;
CosmosRequestHandler handler = client.RequestHandler.InnerHandler;
while (handler != null)
{
if (handler.InnerHandler is RouterHandler)
{
handler.InnerHandler = new RouterHandler(partitionKeyRangeHandler, testHandler);
break;
}
handler = handler.InnerHandler;
}
CosmosJsonSerializer cosmosJsonSerializer = new CosmosJsonSerializerCore();
CosmosResponseFactory responseFactory = new CosmosResponseFactory(cosmosJsonSerializer, cosmosJsonSerializer);
return(new CosmosClientContextCore(
client: client,
clientOptions: null,
userJsonSerializer: cosmosJsonSerializer,
defaultJsonSerializer: cosmosJsonSerializer,
cosmosResponseFactory: responseFactory,
requestHandler: client.RequestHandler,
documentClient: new MockDocumentClient(),
documentQueryClient: new Mock <Query.IDocumentQueryClient>().Object));
}
private async Task VerifyItemNullExceptions(
dynamic testItem,
ItemRequestOptions requestOptions = null)
{
TestHandler testHandler = new TestHandler((request, cancellationToken) =>
{
Assert.Fail("Null partition key should be blocked without the correct request option");
return null;
});
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler));
CosmosContainer container = client.Databases["testdb"]
.Containers["testcontainer"];
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.CreateItemAsync<dynamic>(
partitionKey: null,
item: testItem,
requestOptions: requestOptions);
}, "CreateItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.ReadItemAsync<dynamic>(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "ReadItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.UpsertItemAsync<dynamic>(
partitionKey: null,
item: testItem,
requestOptions: requestOptions);
}, "UpsertItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.ReplaceItemAsync<dynamic>(
partitionKey: null,
id: testItem.id,
item: testItem,
requestOptions: requestOptions);
}, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.DeleteItemAsync<dynamic>(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "DeleteItemAsync should throw ArgumentNullException without the correct request option set.");
CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore();
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.CreateItemAsStreamAsync(
partitionKey: null,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "CreateItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.ReadItemAsStreamAsync(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "ReadItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.UpsertItemAsStreamAsync(
partitionKey: null,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "UpsertItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.ReplaceItemAsStreamAsync(
partitionKey: null,
id: testItem.id,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () =>
{
await container.DeleteItemAsStreamAsync(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "DeleteItemAsync should throw ArgumentNullException without the correct request option set.");
}
}
private async Task VerifyItemOperations(
object partitionKey,
string partitionKeySerialized,
dynamic testItem,
ItemRequestOptions requestOptions = null)
{
CosmosResponseMessage response = null;
HttpStatusCode httpStatusCode = HttpStatusCode.OK;
int testHandlerHitCount = 0;
TestHandler testHandler = new TestHandler((request, cancellationToken) =>
{
Assert.IsTrue(request.RequestUri.OriginalString.StartsWith(@"/dbs/testdb/colls/testcontainer"));
Assert.AreEqual(requestOptions, request.RequestOptions);
Assert.AreEqual(ResourceType.Document, request.ResourceType);
Assert.IsNotNull(request.Headers.PartitionKey);
Assert.AreEqual(partitionKeySerialized, request.Headers.PartitionKey);
testHandlerHitCount++;
response = new CosmosResponseMessage(httpStatusCode, request, errorMessage: null);
response.Content = request.Content;
return Task.FromResult(response);
});
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient(
(builder) => builder.AddCustomHandlers(testHandler));
CosmosContainer container = client.Databases["testdb"]
.Containers["testcontainer"];
ItemResponse<dynamic> itemResponse = await container.CreateItemAsync<dynamic>(
partitionKey: partitionKey,
item: testItem,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.ReadItemAsync<dynamic>(
partitionKey: partitionKey,
id: testItem.id,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.UpsertItemAsync<dynamic>(
partitionKey: partitionKey,
item: testItem,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.ReplaceItemAsync<dynamic>(
partitionKey: partitionKey,
id: testItem.id,
item: testItem,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
itemResponse = await container.DeleteItemAsync<dynamic>(
partitionKey: partitionKey,
id: testItem.id,
requestOptions: requestOptions);
Assert.IsNotNull(itemResponse);
Assert.AreEqual(httpStatusCode, itemResponse.StatusCode);
Assert.AreEqual(5, testHandlerHitCount, "An operation did not make it to the handler");
CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore();
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.CreateItemAsStreamAsync(
partitionKey: partitionKey,
streamPayload: itemStream))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.ReadItemAsStreamAsync(
partitionKey: partitionKey,
id: testItem.id,
requestOptions: requestOptions))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.UpsertItemAsStreamAsync(
partitionKey: partitionKey,
streamPayload: itemStream,
requestOptions: requestOptions))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.ReplaceItemAsStreamAsync(
partitionKey: partitionKey,
id: testItem.id,
streamPayload: itemStream,
requestOptions: requestOptions))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem))
{
using (CosmosResponseMessage streamResponse = await container.DeleteItemAsStreamAsync(
partitionKey: partitionKey,
id: testItem.id,
requestOptions: requestOptions))
{
Assert.IsNotNull(streamResponse);
Assert.AreEqual(httpStatusCode, streamResponse.StatusCode);
}
}
Assert.AreEqual(10, testHandlerHitCount, "A stream operation did not make it to the handler");
}
public async Task StandByFeedIterator()
{
int totalCount = 0;
string lastcontinuation = string.Empty;
int firstRunTotal = 25;
int batchSize = 25;
Documents.Routing.Range <string> previousRange = null;
Documents.Routing.Range <string> currentRange = null;
int pkRangesCount = (await this.Container.ClientContext.DocumentClient.ReadPartitionKeyRangeFeedAsync(this.Container.LinkUri)).Count;
int visitedPkRanges = 0;
await this.CreateRandomItems(batchSize, randomPartitionKey : true);
ContainerCore itemsCore = (ContainerCore)this.Container;
FeedIterator feedIterator = itemsCore.GetStandByFeedIterator(requestOptions: new ChangeFeedRequestOptions()
{
StartTime = DateTime.MinValue
});
while (feedIterator.HasMoreResults)
{
using (ResponseMessage responseMessage =
await feedIterator.ReadNextAsync(this.cancellationToken))
{
lastcontinuation = responseMessage.Headers.Continuation;
List <CompositeContinuationToken> deserializedToken = JsonConvert.DeserializeObject <List <CompositeContinuationToken> >(lastcontinuation);
currentRange = deserializedToken[0].Range;
Assert.AreEqual(pkRangesCount, deserializedToken.Count);
if (responseMessage.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data;
totalCount += response.Count;
}
if (!currentRange.Equals(previousRange))
{
visitedPkRanges++;
}
if (visitedPkRanges == pkRangesCount && responseMessage.StatusCode == System.Net.HttpStatusCode.NotModified)
{
break;
}
previousRange = currentRange;
}
}
Assert.AreEqual(firstRunTotal, totalCount);
int expectedFinalCount = 50;
previousRange = null;
currentRange = null;
visitedPkRanges = 0;
// Insert another batch of 25 and use the last continuation token from the first cycle
await this.CreateRandomItems(batchSize, randomPartitionKey : true);
FeedIterator setIteratorNew =
itemsCore.GetStandByFeedIterator(lastcontinuation);
while (setIteratorNew.HasMoreResults)
{
using (ResponseMessage responseMessage =
await setIteratorNew.ReadNextAsync(this.cancellationToken))
{
lastcontinuation = responseMessage.Headers.Continuation;
currentRange = JsonConvert.DeserializeObject <List <CompositeContinuationToken> >(lastcontinuation)[0].Range;
if (responseMessage.IsSuccessStatusCode)
{
Collection <ToDoActivity> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <ToDoActivity> >(responseMessage.Content).Data;
totalCount += response.Count;
}
if (!currentRange.Equals(previousRange))
{
visitedPkRanges++;
}
if (visitedPkRanges == pkRangesCount && responseMessage.StatusCode == System.Net.HttpStatusCode.NotModified)
{
break;
}
previousRange = currentRange;
}
}
Assert.AreEqual(expectedFinalCount, totalCount);
}
private async Task VerifyItemNullPartitionKeyExpectations(
dynamic testItem,
ItemRequestOptions requestOptions = null)
{
TestHandler testHandler = new TestHandler((request, cancellationToken) =>
{
Assert.IsNotNull(request.Headers.PartitionKey);
Assert.AreEqual(Documents.Routing.PartitionKeyInternal.Undefined.ToString(), request.Headers.PartitionKey.ToString());
return(Task.FromResult(new CosmosResponseMessage(HttpStatusCode.OK)));
});
CosmosClient client = MockCosmosUtil.CreateMockCosmosClient(
(cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler));
CosmosContainer container = client.GetDatabase("testdb")
.GetContainer("testcontainer");
await container.CreateItemAsync <dynamic>(
item : testItem,
requestOptions : requestOptions);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.ReadItemAsync <dynamic>(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "ReadItemAsync should throw ArgumentNullException without the correct request option set.");
await container.UpsertItemAsync <dynamic>(
item : testItem,
requestOptions : requestOptions);
await container.ReplaceItemAsync <dynamic>(
id : testItem.id,
item : testItem,
requestOptions : requestOptions);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.DeleteItemAsync <dynamic>(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "DeleteItemAsync should throw ArgumentNullException without the correct request option set.");
CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore();
using (Stream itemStream = jsonSerializer.ToStream <dynamic>(testItem))
{
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.CreateItemStreamAsync(
partitionKey: null,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "CreateItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.ReadItemStreamAsync(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "ReadItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.UpsertItemStreamAsync(
partitionKey: null,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "UpsertItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.ReplaceItemStreamAsync(
partitionKey: null,
id: testItem.id,
streamPayload: itemStream,
requestOptions: requestOptions);
}, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set.");
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
{
await container.DeleteItemStreamAsync(
partitionKey: null,
id: testItem.id,
requestOptions: requestOptions);
}, "DeleteItemAsync should throw ArgumentNullException without the correct request option set.");
}
}