public async Task TestCollectionModelFullFail()
{
IDocumentDatabase db = _documentServer.GetDatabase(_workContext, _dbName);
foreach (var variation in Enumerable.Range(1, 2))
{
CollectionModel model = CreateCollectionModel(variation);
var package = new CollectionModelPackage(db, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
package = new CollectionModelPackage(db, model, new CollectionModelSettings());
result = await package.Test(_workContext);
result.Should().BeTrue();
model.Indexes[0].Keys.Add(new IndexKey {
FieldName = "xxxx"
});
result = await package.Test(_workContext);
result.Should().BeFalse();
await db.DropCollection(_workContext, _collectionName);
}
await _documentServer.DropDatabase(_workContext, _dbName);
}
public async Task ApplyUpdateRemovedCollection()
{
IDocumentDatabase db = _documentServer.GetDatabase(_workContext, _dbName);
CollectionModel model = CreateCollectionModel(3);
var package = new CollectionModelPackage(db, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
(await VerifyCollectionModel(db, model)).Should().BeTrue();
model = CreateCollectionModel(0);
var updatePackage = new CollectionModelPackage(db, model, new CollectionModelSettings {
Remove = true
});
result = await updatePackage.Apply(_workContext);
result.Should().BeTrue();
(await db.CollectionExist(_workContext, _collectionName)).Should().BeFalse();
await db.DropCollection(_workContext, _collectionName);
await _documentServer.DropDatabase(_workContext, _dbName);
}
public async Task ApplyCappedCollectionModelWithoutIndex()
{
const int maxDocuments = 100;
const int maxSizeInBytes = maxDocuments * 1000;
var model = new CappedCollectionModel
{
CollectionName = _collectionName,
MaxSizeInBytes = maxSizeInBytes,
MaxNumberOfDocuments = maxDocuments,
};
var package = new CollectionModelPackage(_documentDatabase, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
(await _documentDatabase.CollectionExist(_workContext, _collectionName)).Should().BeTrue();
CollectionDetailV1 detail = await _documentDatabase.GetCollectionDetail(_workContext, _collectionName);
detail.Should().NotBeNull();
detail.Name.Should().Be(_collectionName);
detail.Type.Should().Be("collection");
detail.Readonly.Should().BeFalse();
detail.Capped.Should().BeTrue();
detail.MaxDocuments.Should().HaveValue();
detail.MaxDocuments.Should().Be(maxDocuments);
detail.MaxSizeInBytes.Should().HaveValue();
detail.MaxSizeInBytes.Should().BeGreaterOrEqualTo(maxSizeInBytes);
}
public CreateIndexState(CollectionModelPackage parent, CollectionIndex index)
{
Verify.IsNotNull(nameof(parent), parent);
Verify.IsNotNull(nameof(index), index);
Verify.IsNotEmpty(nameof(index.Name), index.Name);
Parent = parent;
Index = index;
}
public async Task ApplyCappedCollectionModelWithIndex()
{
const int maxDocuments = 100;
const int maxSizeInBytes = maxDocuments * 1000;
var model = new CappedCollectionModel
{
CollectionName = _collectionName,
MaxSizeInBytes = maxSizeInBytes,
MaxNumberOfDocuments = maxDocuments,
Indexes = new List <CollectionIndex>
{
new CollectionIndex
{
Name = "TestIndex_1",
Unique = true,
Keys = new List <IndexKey>
{
new IndexKey {
FieldName = "Field1", Descending = false
},
}
}
}
};
var package = new CollectionModelPackage(_documentDatabase, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
(await _documentDatabase.CollectionExist(_workContext, _collectionName)).Should().BeTrue();
CollectionDetailV1 detail = await _documentDatabase.GetCollectionDetail(_workContext, _collectionName);
detail.Should().NotBeNull();
detail.Name.Should().Be(_collectionName);
detail.Type.Should().Be("collection");
detail.Readonly.Should().BeFalse();
detail.Capped.Should().BeTrue();
detail.MaxDocuments.Should().HaveValue();
detail.MaxDocuments.Should().Be(maxDocuments);
detail.MaxSizeInBytes.Should().HaveValue();
detail.MaxSizeInBytes.Should().BeGreaterOrEqualTo(maxSizeInBytes);
IDocumentCollection <TestDocument> collection = _documentDatabase.GetCollection <TestDocument>(_collectionName);
IndexDetailV1 indexDetail = await collection.Index.GetIndexDetail(_workContext, model.Indexes[0].Name);
indexDetail.Should().NotBeNull();
indexDetail.Keys.Count.Should().Be(1);
model.Indexes[0].IsEquals(indexDetail).Should().BeTrue();
}
/// <summary>
/// Apply collection model, create collection and its create indexes
/// </summary>
/// <param name="context">context</param>
/// <returns>task</returns>
public async Task ApplyCollectionModels(IWorkContext context)
{
Verify.IsNotNull(nameof(context), context);
context = context.WithTag(_tag);
IDocumentDatabase db = _documentServer.GetDatabase(_configuration.DatabaseName);
foreach (var model in _models)
{
context.Telemetry.Info(context, $"{nameof(ApplyCollectionModels)} for collection={model.CollectionName}");
var package = new CollectionModelPackage(db, model);
await package.Apply(context).ConfigureAwait(false);
}
}
public async Task SmallCappedOverFiveCollectionTest()
{
const int maxDocuments = 10;
const int maxSizeInBytes = maxDocuments * 1000;
const int createDocumentCount = maxDocuments + 5;
var model = new CappedCollectionModel
{
CollectionName = _collectionName,
MaxSizeInBytes = maxSizeInBytes,
MaxNumberOfDocuments = maxDocuments,
};
var package = new CollectionModelPackage(_documentDatabase, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
IDocumentCollection <TestDocument> collection = _documentDatabase.GetCollection <TestDocument>(_collectionName);
foreach (var index in Enumerable.Range(0, createDocumentCount))
{
TestDocument doc = CreateTestDocument(index);
await collection.Insert(_workContext, doc);
}
long count = await collection.Count(_workContext);
count.Should().Be(maxDocuments);
IEnumerable <TestDocument> results = await collection.Find(_workContext, new BsonDocument());
results.Should().NotBeNull();
results.Count().Should().Be(maxDocuments);
int testIndex = createDocumentCount - maxDocuments;
foreach (var item in results.OrderBy(x => x.Index))
{
TestDocument compareDoc = CreateTestDocument(testIndex++);
item.IsEqual(compareDoc).Should().BeTrue();
}
}
public async Task ApplyCollectionModelFull()
{
IDocumentDatabase db = _documentServer.GetDatabase(_workContext, _dbName);
var model = new CollectionModel
{
CollectionName = _collectionName,
Indexes = new List <CollectionIndex>
{
new CollectionIndex
{
Name = "TestIndex_1",
Unique = true,
Keys = new List <IndexKey>
{
new IndexKey {
FieldName = "Field1", Descending = false
},
}
}
}
};
var package = new CollectionModelPackage(db, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
(await db.CollectionExist(_workContext, _collectionName)).Should().BeTrue();
IDocumentCollection <TestDocument> collection = db.GetCollection <TestDocument>(_collectionName);
IndexDetailV1 detail = await collection.Index.GetIndexDetail(_workContext, model.Indexes[0].Name);
detail.Should().NotBeNull();
detail.Keys.Count.Should().Be(1);
model.Indexes[0].IsEquals(detail).Should().BeTrue();
await db.DropCollection(_workContext, _collectionName);
await _documentServer.DropDatabase(_workContext, _dbName);
}
public async Task ApplyCollectionModelMultipleIndexesFull()
{
IDocumentDatabase db = _documentServer.GetDatabase(_workContext, _dbName);
CollectionModel model = CreateCollectionModel(2);
var package = new CollectionModelPackage(db, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
(await VerifyCollectionModel(db, model)).Should().BeTrue();
await db.DropCollection(_workContext, _collectionName);
await _documentServer.DropDatabase(_workContext, _dbName);
}
public async Task ApplyCollectionModelCompositeKeyFull()
{
IDocumentDatabase db = _documentServer.GetDatabase(_workContext, _dbName);
var model = new CollectionModel
{
CollectionName = _collectionName,
Indexes = new List <CollectionIndex>
{
new CollectionIndex
{
Name = "TestIndex_1",
Unique = true,
Keys = new List <IndexKey>
{
new IndexKey {
FieldName = "Field1", Descending = false
},
new IndexKey {
FieldName = "Field2", Descending = true
},
}
}
}
};
var package = new CollectionModelPackage(db, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
(await VerifyCollectionModel(db, model)).Should().BeTrue();
await db.DropCollection(_workContext, _collectionName);
await _documentServer.DropDatabase(_workContext, _dbName);
}
public async Task TestCollectionModelFull()
{
IDocumentDatabase db = _documentServer.GetDatabase(_workContext, _dbName);
CollectionModel model = CreateCollectionModel(1);
var package = new CollectionModelPackage(db, model, new CollectionModelSettings {
ReCreate = true
});
bool result = await package.Apply(_workContext);
result.Should().BeTrue();
package = new CollectionModelPackage(db, model, new CollectionModelSettings());
result = await package.Test(_workContext);
result.Should().BeTrue();
await db.DropCollection(_workContext, _collectionName);
await _documentServer.DropDatabase(_workContext, _dbName);
}
public RemoveCollectionState(CollectionModelPackage parent)
{
Parent = parent;
}
public RemoveIndexesNotInSource(CollectionModelPackage parent)
{
Verify.IsNotNull(nameof(parent), parent);
Parent = parent;
}
public CreateCollectionState(CollectionModelPackage parent)
{
Parent = parent;
}
