public async Task PartitionedCRUDTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
ContainerResponse containerResponse =
await this.database.DefineContainer(containerName, partitionKeyPath)
.WithIndexingPolicy()
.WithIndexingMode(Cosmos.IndexingMode.None)
.WithAutomaticIndexing(false)
.Attach()
.CreateAsync();
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
CosmosContainer cosmosContainer = containerResponse;
Assert.AreEqual(Cosmos.IndexingMode.None, containerResponse.Resource.IndexingPolicy.IndexingMode);
Assert.IsFalse(containerResponse.Resource.IndexingPolicy.Automatic);
containerResponse = await cosmosContainer.ReadAsync();
Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
Assert.AreEqual(Cosmos.IndexingMode.None, containerResponse.Resource.IndexingPolicy.IndexingMode);
Assert.IsFalse(containerResponse.Resource.IndexingPolicy.Automatic);
containerResponse = await containerResponse.Container.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task TimeToLiveTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
int timeToLiveInSeconds = 10;
ContainerResponse containerResponse = await this.database.DefineContainer(containerName, partitionKeyPath)
.WithDefaultTimeToLive(timeToLiveInSeconds)
.CreateAsync();
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
CosmosContainer cosmosContainer = containerResponse;
CosmosContainerSettings responseSettings = containerResponse;
Assert.AreEqual(timeToLiveInSeconds, responseSettings.DefaultTimeToLive);
ContainerResponse readResponse = await cosmosContainer.ReadAsync();
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(timeToLiveInSeconds, readResponse.Resource.DefaultTimeToLive);
JObject itemTest = JObject.FromObject(new { id = Guid.NewGuid().ToString(), users = "testUser42" });
ItemResponse <JObject> createResponse = await cosmosContainer.CreateItemAsync <JObject>(item : itemTest);
JObject responseItem = createResponse;
Assert.IsNull(responseItem["ttl"]);
containerResponse = await cosmosContainer.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
private static async Task ReadContainerProperties()
{
//*************************************************
// Get a CosmosContainer by its Id property
//*************************************************
CosmosContainer container = database.GetContainer(containerId);
CosmosContainerSettings containerSettings = await container.ReadAsync();
Console.WriteLine($"\n4. Found Container \n{containerSettings.Id}\n");
}
public async Task WithIndexingPolicy()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
ContainerResponse containerResponse =
await this.database.DefineContainer(containerName, partitionKeyPath)
.WithIndexingPolicy()
.WithIncludedPaths()
.Path("/included1/*")
.Path("/included2/*")
.Attach()
.WithExcludedPaths()
.Path("/*")
.Attach()
.WithCompositeIndex()
.Path("/composite1")
.Path("/composite2", CompositePathSortOrder.Descending)
.Attach()
.Attach()
.CreateAsync();
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
CosmosContainer cosmosContainer = containerResponse;
Assert.AreEqual(2, containerResponse.Resource.IndexingPolicy.IncludedPaths.Count);
Assert.AreEqual("/included1/*", containerResponse.Resource.IndexingPolicy.IncludedPaths[0].Path);
Assert.AreEqual("/included2/*", containerResponse.Resource.IndexingPolicy.IncludedPaths[1].Path);
Assert.AreEqual("/*", containerResponse.Resource.IndexingPolicy.ExcludedPaths[0].Path);
Assert.AreEqual(1, containerResponse.Resource.IndexingPolicy.CompositeIndexes.Count);
Assert.AreEqual("/composite1", containerResponse.Resource.IndexingPolicy.CompositeIndexes[0][0].Path);
Assert.AreEqual("/composite2", containerResponse.Resource.IndexingPolicy.CompositeIndexes[0][1].Path);
Assert.AreEqual(CompositePathSortOrder.Descending, containerResponse.Resource.IndexingPolicy.CompositeIndexes[0][1].Order);
containerResponse = await cosmosContainer.ReadAsync();
Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
Assert.AreEqual(2, containerResponse.Resource.IndexingPolicy.IncludedPaths.Count);
Assert.AreEqual("/included1/*", containerResponse.Resource.IndexingPolicy.IncludedPaths[0].Path);
Assert.AreEqual("/included2/*", containerResponse.Resource.IndexingPolicy.IncludedPaths[1].Path);
Assert.AreEqual("/*", containerResponse.Resource.IndexingPolicy.ExcludedPaths[0].Path);
Assert.AreEqual(1, containerResponse.Resource.IndexingPolicy.CompositeIndexes.Count);
Assert.AreEqual("/composite1", containerResponse.Resource.IndexingPolicy.CompositeIndexes[0][0].Path);
Assert.AreEqual("/composite2", containerResponse.Resource.IndexingPolicy.CompositeIndexes[0][1].Path);
Assert.AreEqual(CompositePathSortOrder.Descending, containerResponse.Resource.IndexingPolicy.CompositeIndexes[0][1].Order);
containerResponse = await containerResponse.Container.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task PartitionedCRUDTest()
{
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());
CosmosContainerSettings settings = new CosmosContainerSettings(containerName, partitionKeyPath)
{
IndexingPolicy = new Cosmos.IndexingPolicy()
{
IndexingMode = Cosmos.IndexingMode.None,
Automatic = false
}
};
CosmosContainer cosmosContainer = containerResponse;
containerResponse = await cosmosContainer.ReplaceAsync(settings);
Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
Assert.AreEqual(Cosmos.IndexingMode.None, containerResponse.Resource.IndexingPolicy.IndexingMode);
Assert.IsFalse(containerResponse.Resource.IndexingPolicy.Automatic);
containerResponse = await cosmosContainer.ReadAsync();
Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(Cosmos.PartitionKeyDefinitionVersion.V2, containerResponse.Resource.PartitionKeyDefinitionVersion);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
Assert.AreEqual(Cosmos.IndexingMode.None, containerResponse.Resource.IndexingPolicy.IndexingMode);
Assert.IsFalse(containerResponse.Resource.IndexingPolicy.Automatic);
containerResponse = await containerResponse.Container.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task TimeToLiveTest()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
TimeSpan timeToLive = TimeSpan.FromSeconds(1);
CosmosContainerSettings setting = new CosmosContainerSettings()
{
Id = containerName,
PartitionKey = new PartitionKeyDefinition()
{
Paths = new Collection <string> {
partitionKeyPath
}, Kind = PartitionKind.Hash
},
DefaultTimeToLive = timeToLive
};
CosmosContainerResponse containerResponse = await this.cosmosDatabase.Containers.CreateContainerIfNotExistsAsync(setting);
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
CosmosContainer cosmosContainer = containerResponse;
CosmosContainerSettings responseSettings = containerResponse;
Assert.AreEqual(timeToLive.TotalSeconds, responseSettings.DefaultTimeToLive.Value.TotalSeconds);
CosmosContainerResponse readResponse = await cosmosContainer.ReadAsync();
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(timeToLive.TotalSeconds, readResponse.Resource.DefaultTimeToLive.Value.TotalSeconds);
JObject itemTest = JObject.FromObject(new { id = Guid.NewGuid().ToString(), users = "testUser42" });
CosmosItemResponse <JObject> createResponse = await cosmosContainer.Items.CreateItemAsync <JObject>(partitionKey : itemTest["users"].ToString(), item : itemTest);
JObject responseItem = createResponse;
Assert.IsNull(responseItem["ttl"]);
containerResponse = await cosmosContainer.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
public async Task WithUniqueKeys()
{
string containerName = Guid.NewGuid().ToString();
string partitionKeyPath = "/users";
ContainerResponse containerResponse =
await this.database.DefineContainer(containerName, partitionKeyPath)
.WithUniqueKey()
.Path("/attribute1")
.Path("/attribute2")
.Attach()
.CreateAsync();
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
CosmosContainer cosmosContainer = containerResponse;
Assert.AreEqual(1, containerResponse.Resource.UniqueKeyPolicy.UniqueKeys.Count);
Assert.AreEqual(2, containerResponse.Resource.UniqueKeyPolicy.UniqueKeys[0].Paths.Count);
Assert.AreEqual("/attribute1", containerResponse.Resource.UniqueKeyPolicy.UniqueKeys[0].Paths[0]);
Assert.AreEqual("/attribute2", containerResponse.Resource.UniqueKeyPolicy.UniqueKeys[0].Paths[1]);
containerResponse = await cosmosContainer.ReadAsync();
Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode);
Assert.AreEqual(containerName, containerResponse.Resource.Id);
Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First());
Assert.AreEqual(1, containerResponse.Resource.UniqueKeyPolicy.UniqueKeys.Count);
Assert.AreEqual(2, containerResponse.Resource.UniqueKeyPolicy.UniqueKeys[0].Paths.Count);
Assert.AreEqual("/attribute1", containerResponse.Resource.UniqueKeyPolicy.UniqueKeys[0].Paths[0]);
Assert.AreEqual("/attribute2", containerResponse.Resource.UniqueKeyPolicy.UniqueKeys[0].Paths[1]);
containerResponse = await containerResponse.Container.DeleteAsync();
Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode);
}
internal static async Task <DocumentServiceLeaseStoreManager> InitializeLeaseStoreManagerAsync(
DocumentServiceLeaseStoreManager documentServiceLeaseStoreManager,
CosmosContainer leaseContainer,
string leaseContainerPrefix,
string instanceName)
{
if (documentServiceLeaseStoreManager == null)
{
CosmosContainerResponse cosmosContainerResponse = await leaseContainer.ReadAsync().ConfigureAwait(false);
CosmosContainerSettings containerSettings = cosmosContainerResponse.Resource;
bool isPartitioned =
containerSettings.PartitionKey != null &&
containerSettings.PartitionKey.Paths != null &&
containerSettings.PartitionKey.Paths.Count > 0;
if (isPartitioned &&
(containerSettings.PartitionKey.Paths.Count != 1 || containerSettings.PartitionKey.Paths[0] != "/id"))
{
throw new ArgumentException("The lease collection, if partitioned, must have partition key equal to id.");
}
RequestOptionsFactory requestOptionsFactory = isPartitioned ?
(RequestOptionsFactory) new PartitionedByIdCollectionRequestOptionsFactory() :
(RequestOptionsFactory) new SinglePartitionRequestOptionsFactory();
DocumentServiceLeaseStoreManagerBuilder leaseStoreManagerBuilder = new DocumentServiceLeaseStoreManagerBuilder()
.WithLeasePrefix(leaseContainerPrefix)
.WithLeaseContainer(leaseContainer)
.WithRequestOptionsFactory(requestOptionsFactory)
.WithHostName(instanceName);
documentServiceLeaseStoreManager = await leaseStoreManagerBuilder.BuildAsync().ConfigureAwait(false);
}
return(documentServiceLeaseStoreManager);
}
private async Task ValidateCollectionIndexProgressHeaders(CosmosClient client)
{
CosmosDatabase db = await client.Databases.CreateDatabaseAsync(Guid.NewGuid().ToString());
try
{
PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition {
Paths = new System.Collections.ObjectModel.Collection <string>(new[] { "/id" }), Kind = PartitionKind.Hash
};
var lazyCollection = new CosmosContainerSettings()
{
Id = Guid.NewGuid().ToString(), PartitionKey = partitionKeyDefinition
};
lazyCollection.IndexingPolicy.IndexingMode = Cosmos.IndexingMode.Lazy;
CosmosContainer lazyContainer = await db.Containers.CreateContainerAsync(lazyCollection);
var consistentCollection = new CosmosContainerSettings()
{
Id = Guid.NewGuid().ToString(), PartitionKey = partitionKeyDefinition
};
consistentCollection.IndexingPolicy.IndexingMode = Cosmos.IndexingMode.Consistent;
CosmosContainer consistentContainer = await db.Containers.CreateContainerAsync(consistentCollection);
var noneIndexCollection = new CosmosContainerSettings()
{
Id = Guid.NewGuid().ToString(), PartitionKey = partitionKeyDefinition
};
noneIndexCollection.IndexingPolicy.Automatic = false;
noneIndexCollection.IndexingPolicy.IndexingMode = Cosmos.IndexingMode.None;
CosmosContainer noneIndexContainer = await db.Containers.CreateContainerAsync(noneIndexCollection);
var doc = new Document()
{
Id = Guid.NewGuid().ToString()
};
await lazyContainer.CreateItemAsync <Document>(doc.Id, doc);
await consistentContainer.CreateItemAsync <Document>(doc.Id, doc);
await noneIndexContainer.CreateItemAsync <Document>(doc.Id, doc);
// Lazy-indexing collection.
{
ContainerResponse collectionResponse = await lazyContainer.ReadAsync(requestOptions : new ContainerRequestOptions {
PopulateQuotaInfo = true
});
Assert.IsTrue(int.Parse(collectionResponse.Headers[HttpConstants.HttpHeaders.CollectionLazyIndexingProgress], CultureInfo.InvariantCulture) >= 0,
"Expect lazy indexer progress when reading lazy collection.");
Assert.AreEqual(100, int.Parse(collectionResponse.Headers[HttpConstants.HttpHeaders.CollectionIndexTransformationProgress], CultureInfo.InvariantCulture),
"Expect reindexer progress when reading lazy collection.");
}
// Consistent-indexing collection.
{
ContainerResponse collectionResponse = await consistentContainer.ReadAsync(requestOptions : new ContainerRequestOptions {
PopulateQuotaInfo = true
});
Assert.IsFalse(collectionResponse.Headers.AllKeys().Contains(HttpConstants.HttpHeaders.CollectionLazyIndexingProgress),
"No lazy indexer progress when reading consistent collection.");
Assert.AreEqual(100, int.Parse(collectionResponse.Headers[HttpConstants.HttpHeaders.CollectionIndexTransformationProgress], CultureInfo.InvariantCulture),
"Expect reindexer progress when reading consistent collection.");
}
// None-indexing collection.
{
ContainerResponse collectionResponse = await noneIndexContainer.ReadAsync(requestOptions : new ContainerRequestOptions {
PopulateQuotaInfo = true
});
Assert.IsFalse(collectionResponse.Headers.AllKeys().Contains(HttpConstants.HttpHeaders.CollectionLazyIndexingProgress),
"No lazy indexer progress when reading none-index collection.");
Assert.AreEqual(100, int.Parse(collectionResponse.Headers[HttpConstants.HttpHeaders.CollectionIndexTransformationProgress], CultureInfo.InvariantCulture),
"Expect reindexer progress when reading none-index collection.");
}
}
finally
{
await db.DeleteAsync();
}
}
public static async Task Main(string[] args)
{
try
{
databaseId = "deviceInformation" + Guid.NewGuid().ToString();
containerId = "device-samples" + Guid.NewGuid().ToString();
IConfigurationRoot configuration = new ConfigurationBuilder()
.AddJsonFile("appSettings.json")
.Build();
string endpoint = configuration["EndPointUrl"];
if (string.IsNullOrEmpty(endpoint))
{
throw new ArgumentNullException("Please specify a valid endpoint in the appSettings.json");
}
string authKey = configuration["AuthorizationKey"];
if (string.IsNullOrEmpty(authKey) || string.Equals(authKey, "Super secret key"))
{
throw new ArgumentException("Please specify a valid AuthorizationKey in the appSettings.json");
}
using (CosmosClient client = new CosmosClient(endpoint, authKey))
{
CosmosDatabase database = await client.Databases.CreateDatabaseIfNotExistsAsync(databaseId);
// Create the container using REST API without a partition key definition
await Program.CreateNonPartitionedContainerAsync(endpoint, authKey);
CosmosContainer container = database.Containers[containerId];
// Read back the same container and verify that partition key path is populated
// Partition key is returned when read from V3 SDK.
CosmosContainerResponse containerResposne = await container.ReadAsync();
if (containerResposne.Resource.PartitionKeyPath != null)
{
Console.WriteLine("Container Partition Key path {0}", containerResposne.Resource.PartitionKeyPath);
}
else
{
throw new Exception("Unexpected error : Partition Key is not populated in a migrated collection");
}
Console.WriteLine("--Demo Item operations with no partition key--");
await Program.ItemOperationsWithNonePartitionKeyValue(container);
Console.WriteLine("--Demo Item operations with valid partition key--");
await Program.ItemOperationsWithValidPartitionKeyValue(container);
Console.WriteLine("--Demo migration of items inserted with no partition key to items with a partition key--");
await Program.MigratedItemsFromNonePartitionKeyToValidPartitionKeyValue(container);
// Clean up the database -- for rerunning the sample
await database.DeleteAsync();
}
}
catch (CosmosException cre)
{
Console.WriteLine(cre.ToString());
}
catch (Exception e)
{
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
finally
{
Console.WriteLine("End of demo, press any key to exit.");
Console.ReadKey();
}
}
[Ignore] //Temporary ignore till we fix emulator issue
public async Task ReadNonPartitionItemAsync()
{
try
{
await this.CreateNonPartitionContainerItem();
await this.CreateUndefinedPartitionItem();
fixedContainer = this.database.Containers[nonPartitionContainerId];
CosmosContainerResponse containerResponse = await fixedContainer.ReadAsync();
Assert.IsTrue(containerResponse.Resource.PartitionKey.Paths.Count > 0);
Assert.AreEqual(PartitionKey.SystemKeyPath, containerResponse.Resource.PartitionKey.Paths[0]);
//Reading item from fixed container with CosmosContainerSettings.NonePartitionKeyValue.
CosmosItemResponse <ToDoActivity> response = await fixedContainer.Items.ReadItemAsync <ToDoActivity>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : nonPartitionItemId);
Assert.IsNotNull(response.Resource);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(nonPartitionItemId, response.Resource.id);
//Adding item to fixed container with CosmosContainerSettings.NonePartitionKeyValue.
ToDoActivity itemWithoutPK = CreateRandomToDoActivity();
CosmosItemResponse <ToDoActivity> createResponseWithoutPk = await fixedContainer.Items.CreateItemAsync <ToDoActivity>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
item : itemWithoutPK);
Assert.IsNotNull(createResponseWithoutPk.Resource);
Assert.AreEqual(HttpStatusCode.Created, createResponseWithoutPk.StatusCode);
Assert.AreEqual(itemWithoutPK.id, createResponseWithoutPk.Resource.id);
//Updating item on fixed container with CosmosContainerSettings.NonePartitionKeyValue.
itemWithoutPK.status = "updatedStatus";
CosmosItemResponse <ToDoActivity> updateResponseWithoutPk = await fixedContainer.Items.ReplaceItemAsync <ToDoActivity>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : itemWithoutPK.id,
item : itemWithoutPK);
Assert.IsNotNull(updateResponseWithoutPk.Resource);
Assert.AreEqual(HttpStatusCode.OK, updateResponseWithoutPk.StatusCode);
Assert.AreEqual(itemWithoutPK.id, updateResponseWithoutPk.Resource.id);
//Adding item to fixed container with non-none PK.
ToDoActivityAfterMigration itemWithPK = CreateRandomToDoActivityAfterMigration("TestPk");
CosmosItemResponse <ToDoActivityAfterMigration> createResponseWithPk = await fixedContainer.Items.CreateItemAsync <ToDoActivityAfterMigration>(
partitionKey : itemWithPK.status,
item : itemWithPK);
Assert.IsNotNull(createResponseWithPk.Resource);
Assert.AreEqual(HttpStatusCode.Created, createResponseWithPk.StatusCode);
Assert.AreEqual(itemWithPK.id, createResponseWithPk.Resource.id);
//Quering items on fixed container with cross partition enabled.
CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r");
CosmosResultSetIterator <dynamic> setIterator = fixedContainer.Items
.CreateItemQuery <dynamic>(sql, maxConcurrency: 1, maxItemCount: 10, requestOptions: new CosmosQueryRequestOptions {
EnableCrossPartitionQuery = true
});
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <dynamic> queryResponse = await setIterator.FetchNextSetAsync();
Assert.AreEqual(3, queryResponse.Count());
}
//Reading all items on fixed container.
setIterator = fixedContainer.Items
.GetItemIterator <dynamic>(maxItemCount: 10);
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <dynamic> queryResponse = await setIterator.FetchNextSetAsync();
Assert.AreEqual(3, queryResponse.Count());
}
//Quering items on fixed container with CosmosContainerSettings.NonePartitionKeyValue.
setIterator = fixedContainer.Items
.CreateItemQuery <dynamic>(sql, partitionKey: CosmosContainerSettings.NonePartitionKeyValue, maxItemCount: 10);
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <dynamic> queryResponse = await setIterator.FetchNextSetAsync();
Assert.AreEqual(2, queryResponse.Count());
}
//Quering items on fixed container with non-none PK.
setIterator = fixedContainer.Items
.CreateItemQuery <dynamic>(sql, partitionKey: itemWithPK.status, maxItemCount: 10);
while (setIterator.HasMoreResults)
{
CosmosQueryResponse <dynamic> queryResponse = await setIterator.FetchNextSetAsync();
Assert.AreEqual(1, queryResponse.Count());
}
//Deleting item from fixed container with CosmosContainerSettings.NonePartitionKeyValue.
CosmosItemResponse <ToDoActivity> deleteResponseWithoutPk = await fixedContainer.Items.DeleteItemAsync <ToDoActivity>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : itemWithoutPK.id);
Assert.IsNull(deleteResponseWithoutPk.Resource);
Assert.AreEqual(HttpStatusCode.NoContent, deleteResponseWithoutPk.StatusCode);
//Deleting item from fixed container with non-none PK.
CosmosItemResponse <ToDoActivityAfterMigration> deleteResponseWithPk = await fixedContainer.Items.DeleteItemAsync <ToDoActivityAfterMigration>(
partitionKey : itemWithPK.status,
id : itemWithPK.id);
Assert.IsNull(deleteResponseWithPk.Resource);
Assert.AreEqual(HttpStatusCode.NoContent, deleteResponseWithPk.StatusCode);
//Reading item from partitioned container with CosmosContainerSettings.NonePartitionKeyValue.
CosmosItemResponse <ToDoActivity> undefinedItemResponse = await Container.Items.ReadItemAsync <ToDoActivity>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : undefinedPartitionItemId);
Assert.IsNotNull(undefinedItemResponse.Resource);
Assert.AreEqual(HttpStatusCode.OK, undefinedItemResponse.StatusCode);
Assert.AreEqual(undefinedPartitionItemId, undefinedItemResponse.Resource.id);
}
finally
{
if (fixedContainer != null)
{
await fixedContainer.DeleteAsync();
}
}
}