public async Task RemoveByIdRemoves()
{
// Arrange
var id = Guid.NewGuid().ToString();
var toRemove = new Dummy
{
Id = id,
Name = "Test"
};
var document = toRemove.ToCosmonautDocument(null);
var resourceResponse = document.ToResourceResponse(HttpStatusCode.OK);
_mockDocumentClient.Setup(x => x.DeleteDocumentAsync(It.IsAny <Uri>(), It.IsAny <RequestOptions>(), CancellationToken.None))
.ReturnsAsync(resourceResponse);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
// Act
var result = await entityStore.RemoveByIdAsync(id);
// Assert
result.IsSuccess.Should().BeTrue();
result.ResourceResponse.Resource.Should().NotBeNull();
result.ResourceResponse.Resource.Should().BeEquivalentTo(document);
result.CosmosOperationStatus.Should().Be(CosmosOperationStatus.Success);
result.ResourceResponse.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task UpsertEntityUpsert()
{
// Arrange
var id = Guid.NewGuid().ToString();
var addedDummy = new Dummy
{
Id = id,
Name = "Test"
};
var document = addedDummy.ToCosmonautDocument();
var resourceResponse = document.ToResourceResponse(HttpStatusCode.OK);
document.SetPropertyValue(nameof(addedDummy.Name), "newTest");
_mockDocumentClient.Setup(x => x.UpsertDocumentAsync(It.IsAny <Uri>(), document.ItIsSameDocument(), It.IsAny <RequestOptions>(), false, CancellationToken.None))
.ReturnsAsync(resourceResponse);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
addedDummy.Name = "newTest";
// Act
var result = await entityStore.UpsertAsync(addedDummy);
// Assert
result.ResourceResponse.Resource.Should().NotBeNull();
result.ResourceResponse.Resource.Should().BeEquivalentTo(document);
}
public static CosmosStore <Dummy> ResponseSetup(IQueryable <Dummy> expected, IQueryable <Dummy> dataSource, ref Mock <IDocumentClient> mockDocumentClient)
{
FeedResponse <Dummy> response = expected.ToFeedResponse();
var mockDocumentQuery = new Mock <IFakeDocumentQuery <Dummy> >();
mockDocumentQuery
.SetupSequence(_ => _.HasMoreResults)
.Returns(true)
.Returns(false);
mockDocumentQuery
.Setup(_ => _.ExecuteNextAsync <Dummy>(It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
var provider = new Mock <IQueryProvider>();
provider
.Setup(_ => _.CreateQuery <Dummy>(It.IsAny <Expression>()))
.Returns(mockDocumentQuery.Object);
mockDocumentQuery.As <IQueryable <Dummy> >().Setup(x => x.Provider).Returns(provider.Object);
mockDocumentQuery.As <IQueryable <Dummy> >().Setup(x => x.Expression).Returns(dataSource.Expression);
mockDocumentQuery.As <IQueryable <Dummy> >().Setup(x => x.ElementType).Returns(dataSource.ElementType);
mockDocumentQuery.As <IQueryable <Dummy> >().Setup(x => x.GetEnumerator()).Returns(dataSource.GetEnumerator);
mockDocumentClient.Setup(x => x.CreateDocumentQuery <Dummy>(It.IsAny <Uri>(),
It.IsAny <FeedOptions>()))
.Returns(mockDocumentQuery.Object);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(mockDocumentClient.Object), "databaseName");
return(entityStore);
}
public async Task <RoomForRentAnnouncement> InsertRoomForRentAnnouncementAsync()
{
var roomForRentAnnouncement = RoomForRentAnnouncement.Builder()
.SetId(Guid.NewGuid())
.SetTitle("Title")
.SetSourceUrl("http://sourceUrl")
.SetCityId(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetDescription("Description")
.SetPrice(100)
.SetCityDistricts(new List <Guid> {
Guid.NewGuid()
})
.SetRoomTypes(new List <RoomTypeEnumeration> {
RoomTypeEnumeration.MultiPerson
})
.Build();
var entity = new RoomForRentAnnouncementEntity
{
Id = roomForRentAnnouncement.Id,
Title = roomForRentAnnouncement.Title,
Created = roomForRentAnnouncement.Created,
CityId = roomForRentAnnouncement.CityId,
SourceUrl = roomForRentAnnouncement.SourceUrl,
Description = roomForRentAnnouncement.Description,
Price = roomForRentAnnouncement.Price,
CityDistricts = roomForRentAnnouncement.CityDistricts,
RoomTypes = roomForRentAnnouncement.RoomTypes.Select(x => x.ConvertToEnum()),
CosmosEntityName = nameof(Domain.RoomForRentAnnouncements.Aggregates.RoomForRentAnnouncement)
};
await CosmosStore.AddAsync(entity);
return(roomForRentAnnouncement);
}
public static CosmosStore <Dummy> ResponseSetupForQuery <T>(string sql, SqlParameterCollection parameters, IQueryable <T> expected, IQueryable <Dummy> dataSource, ref Mock <IDocumentClient> mockDocumentClient)
{
FeedResponse <T> response = expected.ToFeedResponse();
var mockDocumentQuery = new Mock <IFakeDocumentQuery <T> >();
mockDocumentQuery
.SetupSequence(_ => _.HasMoreResults)
.Returns(true)
.Returns(false);
mockDocumentQuery
.Setup(_ => _.ExecuteNextAsync <T>(It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
var provider = new Mock <IQueryProvider>();
provider
.Setup(_ => _.CreateQuery <T>(It.IsAny <Expression>()))
.Returns(mockDocumentQuery.Object);
mockDocumentClient.Setup(x => x.CreateDocumentQuery <T>(It.IsAny <Uri>(), It.Is <SqlQuerySpec>(query => query.QueryText == sql),
It.IsAny <FeedOptions>()))
.Returns(mockDocumentQuery.Object);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(mockDocumentClient.Object), "databaseName");
return(entityStore);
}
public async Task UpdateRangeUpdatesEntities()
{
// Arrange
var id = Guid.NewGuid().ToString();
var addedDummy = new Dummy
{
Id = id,
Name = "Test"
};
addedDummy.ValidateEntityForCosmosDb();
var document = addedDummy.ToCosmonautDocument();
var resourceResponse = document.ToResourceResponse(HttpStatusCode.OK);
document.SetPropertyValue(nameof(addedDummy.Name), "newTest");
_mockDocumentClient.Setup(x => x.ReplaceDocumentAsync(It.IsAny <Uri>(), document.ItIsSameDocument(), It.IsAny <RequestOptions>(), CancellationToken.None))
.ReturnsAsync(resourceResponse);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
addedDummy.Name = "newTest";
// Act
var result = await entityStore.UpdateRangeAsync(new [] { addedDummy });
// Assert
result.FailedEntities.Should().BeEmpty();
result.SuccessfulEntities.Should().HaveCount(1);
result.SuccessfulEntities.Single().ResourceResponse.Resource.Should().NotBeNull();
result.SuccessfulEntities.Single().ResourceResponse.Resource.Should().BeEquivalentTo(document);
}
public void SingleAsyncWithMoreThanOneThrowsException()
{
// Arrange
var singleDummy = new Dummy
{
Id = Guid.NewGuid().ToString(),
Name = "John"
};
var dummies = new List <Dummy>
{
new Dummy
{
Id = Guid.NewGuid().ToString(),
Name = "Nick"
},
singleDummy
};
Expression <Func <Dummy, bool> > predicate = x => true;
var dataSource = dummies.AsQueryable();
var expected = dataSource.Where(predicate);
MockHelpers.ResponseSetup(expected, dataSource, ref _mockDocumentClient);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
// Act
var result = new Action(() => entityStore.Query().SingleAsync(predicate).GetAwaiter().GetResult());
//Assert
result.Should().Throw <InvalidOperationException>().WithMessage("Sequence contains more than one element");
}
public async Task SingleAsyncReturnsObject()
{
// Arrange
var singleDummy = new Dummy
{
Id = Guid.NewGuid().ToString(),
Name = "John"
};
var dummies = new List <Dummy>
{
new Dummy
{
Id = Guid.NewGuid().ToString(),
Name = "Nick"
},
singleDummy
};
Expression <Func <Dummy, bool> > predicate = x => x.Name == "John";
var dataSource = dummies.AsQueryable();
var expected = dataSource.Where(predicate);
MockHelpers.ResponseSetup(expected, dataSource, ref _mockDocumentClient);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
// Act
var result = await entityStore.Query().SingleAsync(predicate);
//Assert
result.Should().BeEquivalentTo(singleDummy);
}
public async Task CosmosStoreSettings_CreatesCollectionWithUniqueKeyPolicy()
{
var cosmosStoreSettings = new CosmosStoreSettings(_databaseId, _emulatorUri, _emulatorKey, settings =>
{
settings.ProvisionInfrastructureIfMissing = true;
settings.ConnectionPolicy = _connectionPolicy;
settings.UniqueKeyPolicy = new UniqueKeyPolicy
{
UniqueKeys =
{
new UniqueKey
{
Paths =
{
"/name",
"/bladiebla"
}
}
}
};
});
var store = new CosmosStore <Lion>(cosmosStoreSettings);
var collection = await store.CosmonautClient.GetCollectionAsync(_databaseId, store.CollectionName);
collection.UniqueKeyPolicy.UniqueKeys.Should().HaveCount(1);
}
public async Task AddRangeParamsValidObjectsSuccess()
{
// Arrange
var dummies = new List <Dummy>();
for (int i = 0; i < 5; i++)
{
var id = i.ToString();
var dummy = new Dummy
{
Id = id,
Name = "Nick"
};
dummies.Add(dummy);
var document = dummy.ConvertObjectToDocument();
var resourceResponse = document.ToResourceResponse(HttpStatusCode.OK);
_mockDocumentClient.Setup(x => x.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri("databaseName", "dummies"),
document.ItIsSameDocument(), It.IsAny <RequestOptions>(), false, CancellationToken.None))
.ReturnsAsync(resourceResponse);
}
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
// Act
var result = await entityStore.AddRangeAsync(dummies[0], dummies[1], dummies[2], dummies[3], dummies[4]);
//Assert
result.IsSuccess.Should().BeTrue();
result.FailedEntities.Should().BeEmpty();
result.SuccessfulEntities.Should().HaveCount(5);
}
public MainGenericDb(AgroDbArguments args)
{
var storeSettings = new CosmosStoreSettings(args.NameDb, args.EndPointUrl, args.PrimaryKey);
Store = new CosmosStore <T>(storeSettings);
BatchStore = new CosmosStore <EntityContainer>(storeSettings);
}
public async Task UpsertEntityUpsert()
{
// Arrange
var id = Guid.NewGuid().ToString();
var addedDummy = new Dummy
{
Id = id,
Name = "Test"
};
var expectedName = "NewTest";
var expectedDocument = new Document
{
Id = id
};
expectedDocument.SetPropertyValue("Name", expectedName);
_mockDocumentClient.Setup(x => x.UpsertDocumentAsync(It.IsAny <string>(), It.IsAny <object>(), It.IsAny <RequestOptions>(), false))
.ReturnsAsync(new ResourceResponse <Document>(expectedDocument));
var entityStore = new CosmosStore <Dummy>(_mockDocumentClient.Object, "databaseName", new CosmosDatabaseCreator(_mockDocumentClient.Object), new CosmosCollectionCreator(_mockDocumentClient.Object));
// Act
var result = await entityStore.UpsertAsync(addedDummy);
// Assert
Assert.Equal(expectedName, result.ResourceResponse.Resource.GetPropertyValue <string>("Name"));
}
public async Task AddValidObjectSuccess()
{
// Arrange
var id = Guid.NewGuid().ToString();
var dummy = new Dummy
{
Id = id,
Name = "Nick"
};
var document = dummy.ConvertObjectToDocument();
var resourceResponse = document.ToResourceResponse(HttpStatusCode.OK);
_mockDocumentClient.Setup(x => x.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri("databaseName", "dummies"),
document.ItIsSameDocument(), It.IsAny <RequestOptions>(), false, CancellationToken.None))
.ReturnsAsync(resourceResponse);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
// Act
var result = await entityStore.AddAsync(dummy);
//Assert
result.IsSuccess.Should().BeTrue();
result.Entity.Should().BeEquivalentTo(dummy);
result.ResourceResponse.Resource.Should().NotBeNull();
result.ResourceResponse.Resource.Should().BeEquivalentTo(document);
result.CosmosOperationStatus.Should().Be(CosmosOperationStatus.Success);
result.ResourceResponse.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task UpdateRangeUpdatesEntities()
{
// Arrange
var id = Guid.NewGuid().ToString();
var addedDummy = new Dummy
{
Id = id,
Name = "Test"
};
addedDummy.ValidateEntityForCosmosDb();
var documentId = addedDummy.GetDocumentId();
var document = addedDummy.GetCosmosDbFriendlyEntity();
JsonReader reader = new JTokenReader(document);
var actualDocument = new Document();
actualDocument.LoadFrom(reader);
JToken jtoken = JToken.FromObject(document);
_mockDocumentClient.Setup(x => x.ReplaceDocumentAsync(DocumentHelpers.GetDocumentSelfLink("databaseName", It.IsAny <string>(), documentId), jtoken, It.IsAny <RequestOptions>())).ReturnsAsync(new ResourceResponse <Document>(actualDocument));
var entityStore = new CosmosStore <Dummy>(_mockDocumentClient.Object, "databaseName", new CosmosDatabaseCreator(_mockDocumentClient.Object), new CosmosCollectionCreator(_mockDocumentClient.Object));
addedDummy.Name = "newTest";
// Act
var result = await entityStore.UpdateRangeAsync(addedDummy);
// Assert
Assert.Empty(result.FailedEntities);
}
public async Task UpdateEntityUpdates()
{
// Arrange
var id = Guid.NewGuid().ToString();
var addedDummy = new Dummy
{
Id = id,
Name = "Test"
};
var expectedName = "NewTest";
addedDummy.ValidateEntityForCosmosDb();
var document = addedDummy.ConvertObjectToDocument();
var resourceResponse = document.ToResourceResponse(HttpStatusCode.OK);
document.SetPropertyValue(nameof(addedDummy.Name), expectedName);
_mockDocumentClient.Setup(x => x.ReplaceDocumentAsync(It.IsAny <Uri>(), document.ItIsSameDocument(), It.IsAny <RequestOptions>())).ReturnsAsync(resourceResponse);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
// Act
addedDummy.Name = expectedName;
var result = await entityStore.UpdateAsync(addedDummy);
// Assert
result.ResourceResponse.Resource.Should().NotBeNull();
result.ResourceResponse.Resource.Should().BeEquivalentTo(document);
}
public async Task <FlatForRentAnnouncement> InsertFlatForRentAnnouncementAsync()
{
var flatForRentAnnouncement = FlatForRentAnnouncement.Builder()
.SetId(Guid.NewGuid())
.SetTitle("Title")
.SetSourceUrl("http://sourceUrl")
.SetCityId(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetDescription("Description")
.SetNumberOfRooms(NumberOfRoomsEnumeration.One)
.SetPrice(100)
.SetCityDistricts(new List <Guid> {
Guid.NewGuid()
})
.Build();
var entity = new FlatForRentAnnouncementEntity
{
Id = flatForRentAnnouncement.Id,
Title = flatForRentAnnouncement.Title,
Created = flatForRentAnnouncement.Created,
CityId = flatForRentAnnouncement.CityId,
SourceUrl = flatForRentAnnouncement.SourceUrl,
Description = flatForRentAnnouncement.Description,
Price = flatForRentAnnouncement.Price,
NumberOfRooms = flatForRentAnnouncement.NumberOfRooms.ConvertToEnum(),
CityDistricts = flatForRentAnnouncement.CityDistricts,
CosmosEntityName = nameof(Domain.FlatForRentAnnouncements.Aggregates.FlatForRentAnnouncement)
};
await CosmosStore.AddAsync(entity);
return(flatForRentAnnouncement);
}
public async Task AddEntityWithoutIdEmptyGeneratedId()
{
// Arrange
var dummy = new Dummy
{
Name = "Nick"
};
var document = dummy.ToCosmonautDocument();
var resourceResponse = document.ToResourceResponse(HttpStatusCode.OK);
_mockDocumentClient.Setup(x => x.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri("databaseName", "dummies"),
document.ItIsSameDocument(), It.IsAny <RequestOptions>(), false, CancellationToken.None))
.ReturnsAsync(resourceResponse);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
// Act
var result = await entityStore.AddAsync(dummy);
//Assert
var isGuid = Guid.TryParse(result.Entity.Id, out var guid);
isGuid.Should().BeTrue();
guid.Should().NotBeEmpty();
result.IsSuccess.Should().BeTrue();
result.ResourceResponse.Resource.Should().NotBeNull();
result.ResourceResponse.Resource.Should().BeEquivalentTo(document);
result.Entity.Should().BeEquivalentTo(dummy);
result.CosmosOperationStatus.Should().Be(CosmosOperationStatus.Success);
result.ResourceResponse.StatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task RemoveEntitiesRemoves()
{
// Arrange
var id = Guid.NewGuid().ToString();
var dummy = new Dummy
{
Id = id,
Name = "Test"
};
var dummies = new List <Dummy> {
dummy
};
var document = dummy.ToCosmonautDocument(null);
var resourceResponse = document.ToResourceResponse(HttpStatusCode.OK);
_mockDocumentClient.Setup(x => x.DeleteDocumentAsync(It.IsAny <Uri>(), It.IsAny <RequestOptions>(), CancellationToken.None))
.ReturnsAsync(resourceResponse);
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(_mockDocumentClient.Object), "databaseName");
// Act
var result = await entityStore.RemoveRangeAsync(dummies);
// Assert
result.IsSuccess.Should().BeTrue();
result.FailedEntities.Should().BeEmpty();
result.SuccessfulEntities.Should().HaveCount(1);
result.SuccessfulEntities.Single().ResourceResponse.Resource.Should().NotBeNull();
result.SuccessfulEntities.Single().ResourceResponse.Resource.Should().BeEquivalentTo(document);
}
public FamilyService(IDatabaseService databaseService, CosmosStore store, ILogger <FamilyService> logger)
{
_databaseService = databaseService;
_store = store;
_logger = logger;
StoreInitialize();
}
public async Task WhenCollectionIsUpScaled_AndAutomaticScalingIsTurnedOff_ThenOfferDoesNotChange()
{
var catStore = new CosmosStore <Cat>(new CosmosStoreSettings(_databaseId, _emulatorUri, _emulatorKey), _collectionName);
var cosmosScaler = new CosmosScaler <Cat>(catStore);
await cosmosScaler.UpscaleCollectionRequestUnitsForRequest(_databaseId, _collectionName, 100, 5);
var offer = await catStore.CosmonautClient.GetOfferV2ForCollectionAsync(_databaseId, _collectionName);
offer.Content.OfferThroughput.Should().Be(400);
}
/// <summary>
/// Obtiene la colección de timestamps de un tipo de elemento
/// </summary>
/// <typeparam name="T">tipo de elemento</typeparam>
/// <returns>Timestamp de todos los elementos de un tipo</returns>
public async Task <long[]> GetTimestamps <T>() where T : DocumentDb
{
var store = new CosmosStore <T>(StoreSettings);
var result = await store.QueryMultipleAsync <long>("SELECT value c._ts FROM c");
if (result == null)
{
return(new List <long>().ToArray());
}
return(result.ToArray());
}
public Repozitorijum(ILoggerFactory dnevnikFabrika, IKonfiguracijaServis konfiguracijaServis)
{
_dnevnik = dnevnikFabrika.CreateLogger <Repozitorijum <T> >();
_konfiguracijaServis = konfiguracijaServis;
_cosmosStorePodesavanja = new CosmosStoreSettings(
_konfiguracijaServis.CosmosDbNazivBaze,
_konfiguracijaServis.CosmosDbUrl,
_konfiguracijaServis.CosmosDbAutKljuc);
_cosmosStore = new CosmosStore <T>(_cosmosStorePodesavanja);
}
public void WithPagination_ThrowsError_WhenPageSizeIsNegativeOrZeroWithToken(int pageSize)
{
// Arrange
var mockDocumentClient = MockHelpers.GetMockDocumentClient();
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(() => mockDocumentClient.Object), "databaseName");
// Act
Action action = () => entityStore.Query().WithPagination(string.Empty, pageSize);
// Assert
action.Should().Throw <ArgumentOutOfRangeException>().WithMessage($"Page size must be a positive number.\r\nParameter name: {nameof(pageSize)}");
}
public async Task CosmosStoreSettings_CreatesCollectionWithSharedEntity_WhenNoUniqueKeyPolicyIsDefined()
{
var cosmosStoreSettings = new CosmosStoreSettings(_databaseId, _emulatorUri, _emulatorKey, settings =>
{
settings.ProvisionInfrastructureIfMissing = true;
settings.ConnectionPolicy = _connectionPolicy;
});
var store = new CosmosStore <Lion>(cosmosStoreSettings);
var collection = await store.CosmonautClient.GetCollectionAsync(_databaseId, store.CollectionName);
collection.UniqueKeyPolicy.UniqueKeys.Should().HaveCount(0);
}
public async Task CosmosStoreCtor_WhenHasCollectionPrefixWithNameOverride_ThenReturnsCorrectCollectionName(string prefix, string collectionName, string expected)
{
// Arrange
var cosmosStoreSettings = new CosmosStoreSettings(_databaseId, _emulatorUri, _emulatorKey,
settings => { settings.CollectionPrefix = prefix; });
// Act
var cosmosStore = new CosmosStore <Cat>(cosmosStoreSettings, collectionName);
// Assert
var collection = await cosmosStore.CosmonautClient.GetCollectionAsync(_databaseId, cosmosStore.CollectionName);
collection.Should().NotBeNull();
cosmosStore.CollectionName.Should().Be(expected);
}
public async Task CosmosStoreCtor_WhenEmptyCollectionPrefix_ThenReturnsCorrectCollectionName(string prefix)
{
// Arrange
var cosmosStoreSettings = new CosmosStoreSettings(_databaseId, _emulatorUri, _emulatorKey,
settings => { settings.CollectionPrefix = prefix; });
// Act
var cosmosStore = new CosmosStore <Cat>(cosmosStoreSettings);
// Assert
var collection = await cosmosStore.CosmonautClient.GetCollectionAsync(_databaseId, cosmosStore.CollectionName);
collection.Should().NotBeNull();
cosmosStore.CollectionName.Should().Be("cats");
}
public async Task WhenRUIntenseOperationHappens_AndAutomaticScalingIsTurnedOn_ThenOfferUpscaledAndDownscaled()
{
var catStore = new CosmosStore <Cat>(new CosmosStoreSettings(_databaseId, _emulatorUri, _emulatorKey,
settings =>
{
settings.DefaultCollectionThroughput = 400;
settings.ScaleCollectionRUsAutomatically = true;
}), _collectionName);
await ExecuteMultipleAddOperationsForType <Cat>(list => catStore.AddRangeAsync(list), 400);
var postScaleOffer = await catStore.CosmonautClient.GetOfferV2ForCollectionAsync(_databaseId, _collectionName);
postScaleOffer.Content.OfferThroughput.Should().Be(400);
}
public async Task WhenCollectionIsUpScaled_AndAutomaticScalingIsTurnedOn_ThenOfferIsUpscaled()
{
var catStore = new CosmosStore <Cat>(new CosmosStoreSettings(_databaseId, _emulatorUri, _emulatorKey,
settings =>
{
settings.DefaultCollectionThroughput = 500;
settings.ScaleCollectionRUsAutomatically = true;
}), _collectionName);
var cosmosScaler = new CosmosScaler <Cat>(catStore);
await cosmosScaler.UpscaleCollectionRequestUnitsForRequest(_databaseId, _collectionName, 100, 5);
var offer = await catStore.CosmonautClient.GetOfferV2ForCollectionAsync(_databaseId, _collectionName);
offer.Content.OfferThroughput.Should().Be(500);
}
public async Task CosmosStoreSettings_CreatesCollectionWithThroughput_WhenThroughputIsPresent()
{
var cosmosStoreSettings = new CosmosStoreSettings(_databaseId, _emulatorUri, _emulatorKey, settings =>
{
settings.ConnectionPolicy = _connectionPolicy;
settings.DefaultCollectionThroughput = 10000;
});
var cosmosStore = new CosmosStore <Cat>(cosmosStoreSettings);
var databaseOffer = await _cosmonautClient.GetOfferV2ForDatabaseAsync(cosmosStore.DatabaseName);
var collectionOffer = await _cosmonautClient.GetOfferV2ForCollectionAsync(cosmosStore.DatabaseName, cosmosStore.CollectionName);
databaseOffer.Should().BeNull();
collectionOffer.Content.OfferThroughput.Should().Be(10000);
}
public static CosmosStore <Dummy> ResponseSetupForQuery(string sql, object parameters, IQueryable <Dummy> expected, IQueryable <Dummy> dataSource, ref Mock <IDocumentClient> mockDocumentClient)
{
FeedResponse <Dummy> response = expected.ToFeedResponse();
var mockDocumentQuery = new Mock <IFakeDocumentQuery <Dummy> >();
mockDocumentQuery
.SetupSequence(_ => _.HasMoreResults)
.Returns(true)
.Returns(false);
mockDocumentQuery
.Setup(_ => _.ExecuteNextAsync <Dummy>(It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
var provider = new Mock <IQueryProvider>();
provider
.Setup(_ => _.CreateQuery <Dummy>(It.IsAny <Expression>()))
.Returns(mockDocumentQuery.Object);
mockDocumentQuery.As <IQueryable <Dummy> >().Setup(x => x.Provider).Returns(provider.Object);
mockDocumentQuery.As <IQueryable <Dummy> >().Setup(x => x.Expression).Returns(dataSource.Expression);
mockDocumentQuery.As <IQueryable <Dummy> >().Setup(x => x.ElementType).Returns(dataSource.ElementType);
mockDocumentQuery.As <IQueryable <Dummy> >().Setup(x => x.GetEnumerator()).Returns(dataSource.GetEnumerator);
if (parameters == null)
{
mockDocumentClient.Setup(x => x.CreateDocumentQuery <Dummy>(It.IsAny <Uri>(), It.Is <SqlQuerySpec>(query => query.QueryText == sql),
It.IsAny <FeedOptions>()))
.Returns(mockDocumentQuery.Object);
}
else
{
var sqlParameters = parameters.ConvertToSqlParameterCollection();
mockDocumentClient.Setup(x => x.CreateDocumentQuery <Dummy>(It.IsAny <Uri>(),
It.Is <SqlQuerySpec>(query => query.QueryText == sql && query.Parameters == sqlParameters),
It.IsAny <FeedOptions>()))
.Returns(mockDocumentQuery.Object);
}
var entityStore = new CosmosStore <Dummy>(new CosmonautClient(mockDocumentClient.Object), "databaseName");
return(entityStore);
}
