private async Task <CosmosContainerProperties> GetContainerSettingsAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); CosmosContainerProperties containerSettings = null; if (this.cosmosQueryContext.ResourceTypeEnum.IsCollectionChild()) { CollectionCache collectionCache = await this.cosmosQueryContext.QueryClient.GetCollectionCacheAsync(); using ( DocumentServiceRequest request = DocumentServiceRequest.Create( OperationType.Query, this.cosmosQueryContext.ResourceTypeEnum, this.cosmosQueryContext.ResourceLink.OriginalString, AuthorizationTokenType.Invalid)) //this request doesn't actually go to server { containerSettings = await collectionCache.ResolveCollectionAsync(request, cancellationToken); } } if (containerSettings == null) { throw new ArgumentException($"The container was not found for resource: {this.cosmosQueryContext.ResourceLink.OriginalString} "); } return(containerSettings); }
public async Task OpenAsync( string databaseName, CosmosContainerProperties collection, CancellationToken cancellationToken) { CollectionRoutingMap routingMap = await this.routingMapProvider.TryLookupAsync(collection.ResourceId, null, null, cancellationToken); if (routingMap == null) { return; } List<PartitionKeyRangeIdentity> ranges = routingMap.OrderedPartitionKeyRanges.Select( range => new PartitionKeyRangeIdentity(collection.ResourceId, range.Id)).ToList(); List<Task> tasks = new List<Task>(); foreach (EndpointCache endpointCache in this.addressCacheByEndpoint.Values) { tasks.Add(endpointCache.AddressCache.OpenAsync(databaseName, collection, ranges, cancellationToken)); } await Task.WhenAll(tasks); }
private ProxyDocumentQueryExecutionContext( IDocumentQueryExecutionContext innerExecutionContext, IDocumentQueryClient client, ResourceType resourceTypeEnum, Type resourceType, Expression expression, FeedOptions feedOptions, string resourceLink, CosmosContainerProperties collection, bool isContinuationExpected, Guid correlatedActivityId) { this.innerExecutionContext = innerExecutionContext; this.client = client; this.resourceTypeEnum = resourceTypeEnum; this.resourceType = resourceType; this.expression = expression; this.feedOptions = feedOptions; this.resourceLink = resourceLink; this.collection = collection; this.isContinuationExpected = isContinuationExpected; this.correlatedActivityId = correlatedActivityId; }
public async Task ImplicitConversion() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; ContainerResponse containerResponse = await this.cosmosDatabase.GetContainer(containerName).ReadAsync(); CosmosContainer cosmosContainer = containerResponse; CosmosContainerProperties cosmosContainerSettings = containerResponse; Assert.AreEqual(HttpStatusCode.NotFound, containerResponse.StatusCode); Assert.IsNotNull(cosmosContainer); Assert.IsNull(cosmosContainerSettings); containerResponse = await this.cosmosDatabase.CreateContainerIfNotExistsAsync(containerName, partitionKeyPath); cosmosContainer = containerResponse; cosmosContainerSettings = containerResponse; Assert.IsNotNull(cosmosContainer); Assert.IsNotNull(cosmosContainerSettings); containerResponse = await cosmosContainer.DeleteAsync(); cosmosContainer = containerResponse; cosmosContainerSettings = containerResponse; Assert.IsNotNull(cosmosContainer); Assert.IsNull(cosmosContainerSettings); }
public void ContainerSettingsSimpleTest() { string id = Guid.NewGuid().ToString(); string pkPath = "/partitionKey"; // Two equivalent definitions CosmosContainerProperties cosmosContainerSettings = new CosmosContainerProperties(id, pkPath); DocumentCollection collection = new DocumentCollection() { Id = id, PartitionKey = new PartitionKeyDefinition() { Paths = new Collection <string>() { pkPath }, } }; string cosmosSerialized = SettingsContractTests.CosmosSerialize(cosmosContainerSettings); string directSerialized = SettingsContractTests.DirectSerialize(collection); // Swap de-serialize and validate CosmosContainerProperties containerDeserSettings = SettingsContractTests.CosmosDeserialize <CosmosContainerProperties>(directSerialized); DocumentCollection collectionDeser = SettingsContractTests.DirectDeSerialize <DocumentCollection>(cosmosSerialized); Assert.AreEqual(collection.Id, containerDeserSettings.Id); Assert.AreEqual(collection.PartitionKey.Paths[0], containerDeserSettings.PartitionKeyPath); Assert.AreEqual(cosmosContainerSettings.Id, collectionDeser.Id); Assert.AreEqual(cosmosContainerSettings.PartitionKeyPath, collectionDeser.PartitionKey.Paths[0]); }
public static ProxyDocumentQueryExecutionContext Create( IDocumentQueryClient client, ResourceType resourceTypeEnum, Type resourceType, Expression expression, FeedOptions feedOptions, string resourceLink, CancellationToken token, CosmosContainerProperties collection, bool isContinuationExpected, Guid correlatedActivityId) { token.ThrowIfCancellationRequested(); DocumentQueryExecutionContextBase.InitParams constructorParams = new DocumentQueryExecutionContextBase.InitParams(client, resourceTypeEnum, resourceType, expression, feedOptions, resourceLink, false, correlatedActivityId); IDocumentQueryExecutionContext innerExecutionContext = new DefaultDocumentQueryExecutionContext(constructorParams, isContinuationExpected); return(new ProxyDocumentQueryExecutionContext(innerExecutionContext, client, resourceTypeEnum, resourceType, expression, feedOptions, resourceLink, collection, isContinuationExpected, correlatedActivityId)); }
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; CosmosContainerProperties 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 void Init() { this.collectionCache = new Mock <ClientCollectionCache>(new ServerStoreModel(null), null, null); this.collectionCache.Setup (m => m.ResolveCollectionAsync( It.IsAny <DocumentServiceRequest>(), It.IsAny <CancellationToken>() ) ).Returns(Task.FromResult(CosmosContainerProperties.CreateWithResourceId("test"))); this.partitionKeyRangeCache = new Mock <PartitionKeyRangeCache>(null, null, null); this.partitionKeyRangeCache.Setup( m => m.TryLookupAsync( It.IsAny <string>(), It.IsAny <CollectionRoutingMap>(), It.IsAny <DocumentServiceRequest>(), It.IsAny <CancellationToken>() ) ).Returns(Task.FromResult <CollectionRoutingMap>(null)); this.globalEndpointManager = new Mock <GlobalEndpointManager>(this, new ConnectionPolicy()); this.InitStoreModels(); }
public async Task ValidateCurrentWriteQuorumAndReplicaSetHeader() { CosmosClient client = TestCommon.CreateCosmosClient(false); CosmosDatabase db = null; try { db = await client.CreateDatabaseAsync(Guid.NewGuid().ToString()); PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition { Paths = new System.Collections.ObjectModel.Collection <string>(new[] { "/id" }), Kind = PartitionKind.Hash }; CosmosContainerProperties containerSetting = new CosmosContainerProperties() { Id = Guid.NewGuid().ToString(), PartitionKey = partitionKeyDefinition }; CosmosContainer coll = await db.CreateContainerAsync(containerSetting); Document documentDefinition = new Document { Id = Guid.NewGuid().ToString() }; ItemResponse <Document> docResult = await coll.CreateItemAsync <Document>(documentDefinition); Assert.IsTrue(int.Parse(docResult.Headers[WFConstants.BackendHeaders.CurrentWriteQuorum], CultureInfo.InvariantCulture) > 0); Assert.IsTrue(int.Parse(docResult.Headers[WFConstants.BackendHeaders.CurrentReplicaSetSize], CultureInfo.InvariantCulture) > 0); } finally { await db.DeleteAsync(); } }
private async Task RefreshAsync(DocumentServiceRequest request, CancellationToken cancellationToken) { System.Diagnostics.Debug.Assert(request.IsNameBased); InternalCache cache = this.GetCache(request.Headers[HttpConstants.HttpHeaders.Version]); string resourceFullName = PathsHelper.GetCollectionPath(request.ResourceAddress); if (request.RequestContext.ResolvedCollectionRid != null) { // Here we will issue backend call only if cache wasn't already refreshed (if whatever is there corresponds to presiously resolved collection rid). await cache.collectionInfoByName.GetAsync( resourceFullName, CosmosContainerProperties.CreateWithResourceId(request.RequestContext.ResolvedCollectionRid), async() => { DateTime currentTime = DateTime.UtcNow; CosmosContainerProperties collection = await this.GetByNameAsync(request.Headers[HttpConstants.HttpHeaders.Version], resourceFullName, cancellationToken); cache.collectionInfoById.Set(collection.ResourceId, collection); cache.collectionInfoByNameLastRefreshTime.AddOrUpdate(resourceFullName, currentTime, (string currentKey, DateTime currentValue) => currentTime); cache.collectionInfoByIdLastRefreshTime.AddOrUpdate(collection.ResourceId, currentTime, (string currentKey, DateTime currentValue) => currentTime); return(collection); }, cancellationToken); } else { // In case of ForceRefresh directive coming from client, there will be no ResolvedCollectionRid, so we // need to refresh unconditionally. this.Refresh(request.ResourceAddress, request.Headers[HttpConstants.HttpHeaders.Version]); } request.RequestContext.ResolvedCollectionRid = null; }
private async Task ContainerOperations(CosmosDatabase database, bool dbNotExist) { // Create should fail if the database does not exist if (dbNotExist) { CosmosContainerProperties newcontainerSettings = new CosmosContainerProperties(id: DoesNotExist, partitionKeyPath: "/pk"); this.VerifyNotFoundResponse(await database.CreateContainerStreamAsync(newcontainerSettings, requestUnitsPerSecond: 500)); } CosmosContainer doesNotExistContainer = database.GetContainer(DoesNotExist); this.VerifyNotFoundResponse(await doesNotExistContainer.ReadStreamAsync()); CosmosContainerProperties containerSettings = new CosmosContainerProperties(id: DoesNotExist, partitionKeyPath: "/pk"); this.VerifyNotFoundResponse(await doesNotExistContainer.ReplaceStreamAsync(containerSettings)); this.VerifyNotFoundResponse(await doesNotExistContainer.DeleteStreamAsync()); // Validate Child resources await this.ItemOperations(doesNotExistContainer, true); // The database exists create a container and validate it's children if (!dbNotExist) { CosmosContainer containerExists = await database.CreateContainerAsync( id : "NotFoundTest" + Guid.NewGuid().ToString(), partitionKeyPath : "/pk"); await this.ItemOperations(containerExists, false); } }
internal virtual async Task <CosmosContainerProperties> ResolveByNameAsync( string apiVersion, string resourceAddress, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); string resourceFullName = PathsHelper.GetCollectionPath(resourceAddress); InternalCache cache = this.GetCache(apiVersion); return(await cache.collectionInfoByName.GetAsync( resourceFullName, null, async() => { DateTime currentTime = DateTime.UtcNow; CosmosContainerProperties collection = await this.GetByNameAsync(apiVersion, resourceFullName, cancellationToken); cache.collectionInfoById.Set(collection.ResourceId, collection); cache.collectionInfoByNameLastRefreshTime.AddOrUpdate(resourceFullName, currentTime, (string currentKey, DateTime currentValue) => currentTime); cache.collectionInfoByIdLastRefreshTime.AddOrUpdate(collection.ResourceId, currentTime, (string currentKey, DateTime currentValue) => currentTime); return collection; }, cancellationToken)); }
/// <summary> /// Resolves a request to a collection in a sticky manner. /// Unless request.ForceNameCacheRefresh is equal to true, it will return the same collection. /// </summary> /// <param name="request">Request to resolve.</param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns>Instance of <see cref="CosmosContainerProperties"/>.</returns> public virtual async Task <CosmosContainerProperties> ResolveCollectionAsync( DocumentServiceRequest request, CancellationToken cancellationToken) { if (request.IsNameBased) { if (request.ForceNameCacheRefresh) { await this.RefreshAsync(request, cancellationToken); request.ForceNameCacheRefresh = false; } CosmosContainerProperties collectionInfo = await this.ResolveByPartitionKeyRangeIdentityAsync( request.Headers[HttpConstants.HttpHeaders.Version], request.PartitionKeyRangeIdentity, cancellationToken); if (collectionInfo != null) { return(collectionInfo); } if (request.RequestContext.ResolvedCollectionRid == null) { collectionInfo = await this.ResolveByNameAsync(request.Headers[HttpConstants.HttpHeaders.Version], request.ResourceAddress, cancellationToken); if (collectionInfo != null) { DefaultTrace.TraceVerbose( "Mapped resourceName {0} to resourceId {1}. '{2}'", request.ResourceAddress, collectionInfo.ResourceId, Trace.CorrelationManager.ActivityId); request.ResourceId = collectionInfo.ResourceId; request.RequestContext.ResolvedCollectionRid = collectionInfo.ResourceId; } else { DefaultTrace.TraceVerbose( "Collection with resourceName {0} not found. '{1}'", request.ResourceAddress, Trace.CorrelationManager.ActivityId); } return(collectionInfo); } else { return(await this.ResolveByRidAsync(request.Headers[HttpConstants.HttpHeaders.Version], request.RequestContext.ResolvedCollectionRid, cancellationToken)); } } else { return(await this.ResolveByPartitionKeyRangeIdentityAsync(request.Headers[HttpConstants.HttpHeaders.Version], request.PartitionKeyRangeIdentity, cancellationToken) ?? await this.ResolveByRidAsync(request.Headers[HttpConstants.HttpHeaders.Version], request.ResourceAddress, cancellationToken)); } }
public async Task ContainerContractTest() { ContainerResponse response = await this.cosmosDatabase.CreateContainerAsync(new Guid().ToString(), "/id"); Assert.IsNotNull(response); Assert.IsTrue(response.RequestCharge > 0); Assert.IsNotNull(response.Headers); Assert.IsNotNull(response.Headers.ActivityId); CosmosContainerProperties containerSettings = response.Resource; Assert.IsNotNull(containerSettings.Id); Assert.IsNotNull(containerSettings.ResourceId); Assert.IsNotNull(containerSettings.ETag); Assert.IsTrue(containerSettings.LastModified.HasValue); Assert.IsNotNull(containerSettings.PartitionKeyPath); Assert.IsNotNull(containerSettings.PartitionKeyPathTokens); Assert.AreEqual(1, containerSettings.PartitionKeyPathTokens.Length); Assert.AreEqual("id", containerSettings.PartitionKeyPathTokens[0]); CosmosContainerCore containerCore = response.Container as CosmosContainerCore; Assert.IsNotNull(containerCore); Assert.IsNotNull(containerCore.LinkUri); Assert.IsFalse(containerCore.LinkUri.ToString().StartsWith("/")); Assert.IsTrue(containerSettings.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), containerSettings.LastModified.Value.ToString()); }
public void ContainerStreamDeserialzieTest() { string colId = "946ad017-14d9-4cee-8619-0cbc62414157"; string rid = "vu9cAA=="; string self = "dbs\\/vu9cAA==\\/cols\\/abc==\\/"; string etag = "00000000-0000-0000-f8ea-31d6e5f701d4"; double ts = 1555923784; DateTime UnixStartTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc); DateTime expected = UnixStartTime.AddSeconds(ts); string testPyaload = "{\"id\":\"" + colId + "\",\"_rid\":\"" + rid + "\",\"_self\":\"" + self + "\",\"_etag\":\"" + etag + "\",\"_colls\":\"colls\\/\",\"_users\":\"users\\/\",\"_ts\":" + ts + "}"; CosmosContainerProperties deserializedPayload = JsonConvert.DeserializeObject <CosmosContainerProperties>(testPyaload); Assert.IsTrue(deserializedPayload.LastModified.HasValue); Assert.AreEqual(expected, deserializedPayload.LastModified.Value); Assert.AreEqual(colId, deserializedPayload.Id); Assert.AreEqual(rid, deserializedPayload.ResourceId); Assert.AreEqual(etag, deserializedPayload.ETag); }
public async Task DoubleRoundTrip() { await cosmosClient.CreateDatabaseIfNotExistsAsync(database.Id); Cosmos.IndexingPolicy indexingPolicy = IndexingPolicyTests.CreateDefaultIndexingPolicy(); CosmosContainerProperties cosmosContainerSettings = new CosmosContainerProperties() { Id = Guid.NewGuid().ToString(), IndexingPolicy = indexingPolicy, }; await IndexingPolicyTests.RoundTripWithLocal(indexingPolicy); }
public async Task NegativePartitionedCreateDelete() { string containerName = Guid.NewGuid().ToString(); PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition(); partitionKeyDefinition.Paths.Add("/users"); partitionKeyDefinition.Paths.Add("/test"); CosmosContainerProperties settings = new CosmosContainerProperties(containerName, partitionKeyDefinition); ContainerResponse containerResponse = await this.cosmosDatabase.CreateContainerAsync(settings); Assert.Fail("Multiple partition keys should have caused an exception."); }
public async Task OpenAsync( string databaseName, CosmosContainerProperties collection, IReadOnlyList <PartitionKeyRangeIdentity> partitionKeyRangeIdentities, CancellationToken cancellationToken) { List <Task <FeedResource <Address> > > tasks = new List <Task <FeedResource <Address> > >(); int batchSize = GatewayAddressCache.DefaultBatchSize; #if !(NETSTANDARD15 || NETSTANDARD16) int userSpecifiedBatchSize = 0; if (int.TryParse(System.Configuration.ConfigurationManager.AppSettings[GatewayAddressCache.AddressResolutionBatchSize], out userSpecifiedBatchSize)) { batchSize = userSpecifiedBatchSize; } #endif string collectionAltLink = string.Format(CultureInfo.InvariantCulture, "{0}/{1}/{2}/{3}", Paths.DatabasesPathSegment, Uri.EscapeUriString(databaseName), Paths.CollectionsPathSegment, Uri.EscapeUriString(collection.Id)); using (DocumentServiceRequest request = DocumentServiceRequest.CreateFromName( OperationType.Read, collectionAltLink, ResourceType.Collection, AuthorizationTokenType.PrimaryMasterKey)) { for (int i = 0; i < partitionKeyRangeIdentities.Count; i += batchSize) { tasks.Add(this.GetServerAddressesViaGatewayAsync( request, collection.ResourceId, partitionKeyRangeIdentities.Skip(i).Take(batchSize).Select(range => range.PartitionKeyRangeId), false)); } } foreach (FeedResource <Address> response in await Task.WhenAll(tasks)) { IEnumerable <Tuple <PartitionKeyRangeIdentity, PartitionAddressInformation> > addressInfos = response.Where(addressInfo => ProtocolFromString(addressInfo.Protocol) == this.protocol) .GroupBy(address => address.PartitionKeyRangeId, StringComparer.Ordinal) .Select(group => this.ToPartitionAddressAndRange(collection.ResourceId, @group.ToList())); foreach (Tuple <PartitionKeyRangeIdentity, PartitionAddressInformation> addressInfo in addressInfos) { this.serverPartitionAddressCache.Set( new PartitionKeyRangeIdentity(collection.ResourceId, addressInfo.Item1.PartitionKeyRangeId), addressInfo.Item2); } } }
public async Task CreateHashV1Container() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; CosmosContainerProperties settings = new CosmosContainerProperties(containerName, partitionKeyPath); settings.PartitionKeyDefinitionVersion = Cosmos.PartitionKeyDefinitionVersion.V1; ContainerResponse cosmosContainerResponse = await this.cosmosDatabase.CreateContainerAsync(settings); Assert.AreEqual(HttpStatusCode.Created, cosmosContainerResponse.StatusCode); Assert.AreEqual(Cosmos.PartitionKeyDefinitionVersion.V1, cosmosContainerResponse.Resource.PartitionKeyDefinitionVersion); }
/// <summary> /// Applies the current Fluent definition and creates a container configuration. /// </summary> /// <returns>Builds the current Fluent configuration into an instance of <see cref="CosmosContainerProperties"/>.</returns> public virtual new CosmosContainerProperties Build() { CosmosContainerProperties settings = base.Build(); if (this.uniqueKeyPolicy != null) { settings.UniqueKeyPolicy = this.uniqueKeyPolicy; } if (this.conflictResolutionPolicy != null) { settings.ConflictResolutionPolicy = this.conflictResolutionPolicy; } return(settings); }
private static async Task RoundTripWithLocal(Cosmos.IndexingPolicy indexingPolicy) { PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition { Paths = new System.Collections.ObjectModel.Collection <string>(new[] { "/id" }), Kind = PartitionKind.Hash }; CosmosContainerProperties containerSetting = new CosmosContainerProperties() { Id = Guid.NewGuid().ToString(), IndexingPolicy = indexingPolicy, PartitionKey = partitionKeyDefinition }; CosmosDatabase cosmosDatabase = await cosmosClient.CreateDatabaseIfNotExistsAsync(IndexingPolicyTests.database.Id); ContainerResponse cosmosContainerResponse = await cosmosDatabase.CreateContainerAsync(containerSetting); Assert.IsTrue(IndexingPolicyTests.indexingPolicyEqualityComparer.Equals(indexingPolicy, containerSetting.IndexingPolicy)); }
/// <summary> /// Gets the list of partition key ranges. /// 1. Check partition key range id /// 2. Check Partition key /// 3. Check the effective partition key /// 4. Get the range from the PartitionedQueryExecutionInfo /// </summary> internal static async Task <List <PartitionKeyRange> > GetTargetPartitionKeyRangesAsync( CosmosQueryClient queryClient, string resourceLink, PartitionedQueryExecutionInfo partitionedQueryExecutionInfo, CosmosContainerProperties collection, QueryRequestOptions queryRequestOptions) { List <PartitionKeyRange> targetRanges; if (queryRequestOptions.PartitionKey != null) { // Dis-ambiguate the NonePK if used PartitionKeyInternal partitionKeyInternal = null; if (Object.ReferenceEquals(queryRequestOptions.PartitionKey, Cosmos.PartitionKey.NonePartitionKeyValue)) { partitionKeyInternal = collection.GetNoneValue(); } else { partitionKeyInternal = new Documents.PartitionKey(queryRequestOptions.PartitionKey.Value).InternalKey; } targetRanges = await queryClient.GetTargetPartitionKeyRangesByEpkStringAsync( resourceLink, collection.ResourceId, partitionKeyInternal.GetEffectivePartitionKeyString(collection.PartitionKey)); } else if (TryGetEpkProperty(queryRequestOptions, out string effectivePartitionKeyString)) { targetRanges = await queryClient.GetTargetPartitionKeyRangesByEpkStringAsync( resourceLink, collection.ResourceId, effectivePartitionKeyString); } else { targetRanges = await queryClient.GetTargetPartitionKeyRangesAsync( resourceLink, collection.ResourceId, partitionedQueryExecutionInfo.QueryRanges); } return(targetRanges); }
public async Task TestConflictResolutionPolicy() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; ContainerResponse containerResponse = await this.database.DefineContainer(containerName, partitionKeyPath) .WithConflictResolution() .WithLastWriterWinsResolution("/lww") .Attach() .CreateAsync(); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); Assert.AreEqual(containerName, containerResponse.Resource.Id); Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First()); CosmosContainerProperties cosmosContainerSettings = containerResponse.Resource; Assert.IsNotNull(cosmosContainerSettings.ConflictResolutionPolicy); Assert.AreEqual(ConflictResolutionMode.LastWriterWins, cosmosContainerSettings.ConflictResolutionPolicy.Mode); Assert.AreEqual("/lww", cosmosContainerSettings.ConflictResolutionPolicy.ConflictResolutionPath); Assert.IsTrue(string.IsNullOrEmpty(cosmosContainerSettings.ConflictResolutionPolicy.ConflictResolutionProcedure)); // Delete container await containerResponse.Container.DeleteAsync(); // Re-create with custom policy string sprocName = "customresolsproc"; containerResponse = await this.database.DefineContainer(containerName, partitionKeyPath) .WithConflictResolution() .WithCustomStoredProcedureResolution(sprocName) .Attach() .CreateAsync(); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); Assert.AreEqual(containerName, containerResponse.Resource.Id); Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First()); cosmosContainerSettings = containerResponse.Resource; Assert.IsNotNull(cosmosContainerSettings.ConflictResolutionPolicy); Assert.AreEqual(ConflictResolutionMode.Custom, cosmosContainerSettings.ConflictResolutionPolicy.Mode); Assert.AreEqual(sprocName, cosmosContainerSettings.ConflictResolutionPolicy.ConflictResolutionProcedure); Assert.IsTrue(string.IsNullOrEmpty(cosmosContainerSettings.ConflictResolutionPolicy.ConflictResolutionPath)); }
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()); CosmosContainerProperties settings = new CosmosContainerProperties(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 void ContainerSettingsDefaults() { string id = Guid.NewGuid().ToString(); string pkPath = "/partitionKey"; SettingsContractTests.TypeAccessorGuard(typeof(CosmosContainerProperties), "Id", "UniqueKeyPolicy", "DefaultTimeToLive", "IndexingPolicy", "TimeToLivePropertyPath", "PartitionKeyPath", "PartitionKeyDefinitionVersion", "ConflictResolutionPolicy"); // Two equivalent definitions CosmosContainerProperties cosmosContainerSettings = new CosmosContainerProperties(id, pkPath); Assert.AreEqual(id, cosmosContainerSettings.Id); Assert.AreEqual(pkPath, cosmosContainerSettings.PartitionKeyPath); Assert.IsNull(cosmosContainerSettings.ResourceId); Assert.IsNull(cosmosContainerSettings.LastModified); Assert.IsNull(cosmosContainerSettings.ETag); Assert.IsNull(cosmosContainerSettings.DefaultTimeToLive); Assert.IsNotNull(cosmosContainerSettings.IndexingPolicy); Assert.IsNotNull(cosmosContainerSettings.ConflictResolutionPolicy); Assert.IsTrue(object.ReferenceEquals(cosmosContainerSettings.IndexingPolicy, cosmosContainerSettings.IndexingPolicy)); Assert.IsNotNull(cosmosContainerSettings.IndexingPolicy.IncludedPaths); Assert.IsTrue(object.ReferenceEquals(cosmosContainerSettings.IndexingPolicy.IncludedPaths, cosmosContainerSettings.IndexingPolicy.IncludedPaths)); Cosmos.IncludedPath ip = new Cosmos.IncludedPath(); Assert.IsNotNull(ip.Indexes); Assert.IsNotNull(cosmosContainerSettings.UniqueKeyPolicy); Assert.IsTrue(object.ReferenceEquals(cosmosContainerSettings.UniqueKeyPolicy, cosmosContainerSettings.UniqueKeyPolicy)); Assert.IsNotNull(cosmosContainerSettings.UniqueKeyPolicy.UniqueKeys); Assert.IsTrue(object.ReferenceEquals(cosmosContainerSettings.UniqueKeyPolicy.UniqueKeys, cosmosContainerSettings.UniqueKeyPolicy.UniqueKeys)); Cosmos.UniqueKey uk = new Cosmos.UniqueKey(); Assert.IsNotNull(uk.Paths); }
public async Task ContainerContractTest() { ContainerResponse response = await this.database.DefineContainer(new Guid().ToString(), "/id") .CreateAsync(); Assert.IsNotNull(response); Assert.IsTrue(response.RequestCharge > 0); Assert.IsNotNull(response.Headers); Assert.IsNotNull(response.Headers.ActivityId); CosmosContainerProperties containerSettings = response.Resource; Assert.IsNotNull(containerSettings.Id); Assert.IsNotNull(containerSettings.ResourceId); Assert.IsNotNull(containerSettings.ETag); Assert.IsTrue(containerSettings.LastModified.HasValue); Assert.IsTrue(containerSettings.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), containerSettings.LastModified.Value.ToString()); }
public async Task PartitionedCreateWithPathDelete() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition(); partitionKeyDefinition.Paths.Add(partitionKeyPath); CosmosContainerProperties settings = new CosmosContainerProperties(containerName, partitionKeyDefinition); ContainerResponse containerResponse = await this.cosmosDatabase.CreateContainerAsync(settings); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); Assert.AreEqual(containerName, containerResponse.Resource.Id); Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First()); 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; CosmosContainerProperties setting = new CosmosContainerProperties() { Id = containerName, PartitionKey = new PartitionKeyDefinition() { Paths = new Collection <string> { partitionKeyPath }, Kind = PartitionKind.Hash }, DefaultTimeToLive = timeToLiveInSeconds, }; ContainerResponse containerResponse = await this.cosmosDatabase.CreateContainerIfNotExistsAsync(setting); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); CosmosContainer cosmosContainer = containerResponse; CosmosContainerProperties 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); }
public async Task StreamPartitionedCreateWithPathDelete() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition(); partitionKeyDefinition.Paths.Add(partitionKeyPath); CosmosContainerProperties settings = new CosmosContainerProperties(containerName, partitionKeyDefinition); using (CosmosResponseMessage containerResponse = await this.cosmosDatabase.CreateContainerStreamAsync(settings)) { Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); } using (CosmosResponseMessage containerResponse = await this.cosmosDatabase.GetContainer(containerName).DeleteStreamAsync()) { Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode); } }
public void ContainerSettingsWithConflictResolution() { string id = Guid.NewGuid().ToString(); string pkPath = "/partitionKey"; // Two equivalent definitions CosmosContainerProperties cosmosContainerSettings = new CosmosContainerProperties(id, pkPath) { ConflictResolutionPolicy = new Cosmos.ConflictResolutionPolicy() { Mode = Cosmos.ConflictResolutionMode.Custom, ConflictResolutionPath = "/path", ConflictResolutionProcedure = "sp" } }; DocumentCollection collection = new DocumentCollection() { Id = id, ConflictResolutionPolicy = new ConflictResolutionPolicy() { Mode = ConflictResolutionMode.Custom, ConflictResolutionPath = "/path", ConflictResolutionProcedure = "sp" } }; string cosmosSerialized = SettingsContractTests.CosmosSerialize(cosmosContainerSettings); string directSerialized = SettingsContractTests.DirectSerialize(collection); // Swap de-serialize and validate CosmosContainerProperties containerDeserSettings = SettingsContractTests.CosmosDeserialize <CosmosContainerProperties>(directSerialized); DocumentCollection collectionDeser = SettingsContractTests.DirectDeSerialize <DocumentCollection>(cosmosSerialized); Assert.AreEqual(cosmosContainerSettings.Id, collectionDeser.Id); Assert.AreEqual((int)cosmosContainerSettings.ConflictResolutionPolicy.Mode, (int)collectionDeser.ConflictResolutionPolicy.Mode); Assert.AreEqual(cosmosContainerSettings.ConflictResolutionPolicy.ConflictResolutionPath, collectionDeser.ConflictResolutionPolicy.ConflictResolutionPath); Assert.AreEqual(cosmosContainerSettings.ConflictResolutionPolicy.ConflictResolutionProcedure, collectionDeser.ConflictResolutionPolicy.ConflictResolutionProcedure); }