CoreIntegrationTests refactored and passing.
This commit is contained in:
alexandre-spieser
@@ -0,0 +1,31 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Attributes;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using System;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
[CollectionName("CoreTestingCollectionNameAttributePartitionedTKey")]
|
||||
public class CorePartitionedCollectionNameDoc : TestDoc, IPartitionedDocument
|
||||
{
|
||||
public CorePartitionedCollectionNameDoc()
|
||||
{
|
||||
PartitionKey = "CoreTestPartitionKeyCollectionName";
|
||||
}
|
||||
|
||||
public string PartitionKey { get; set; }
|
||||
}
|
||||
|
||||
public class CRUDPartitionedCollectionNameAttributeTests : MongoDbDocumentTestBase<CorePartitionedCollectionNameDoc>
|
||||
{
|
||||
public CRUDPartitionedCollectionNameAttributeTests(MongoDbTestFixture<CorePartitionedCollectionNameDoc, Guid> fixture) : base(fixture)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public override string GetClassName()
|
||||
{
|
||||
return "CoreCRUDPartitionedCollectionNameAttributeTests";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using System;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class CorePartitionedDoc : TestDoc, IPartitionedDocument
|
||||
{
|
||||
public CorePartitionedDoc()
|
||||
{
|
||||
PartitionKey = "CoreTestPartitionKey";
|
||||
}
|
||||
|
||||
public string PartitionKey { get; set; }
|
||||
}
|
||||
|
||||
public class CRUDPartitionedTests : MongoDbDocumentTestBase<CorePartitionedDoc>
|
||||
{
|
||||
public CRUDPartitionedTests(MongoDbTestFixture<CorePartitionedDoc, Guid> fixture) : base(fixture)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public override string GetClassName()
|
||||
{
|
||||
return "CoreCRUDPartitionedTests";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Attributes;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using System;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
[CollectionName("TestingCollectionNameAttributePartitionedTKey")]
|
||||
public class CoreTKeyPartitionedCollectionNameDoc : TestDoc<Guid>, IPartitionedDocument
|
||||
{
|
||||
public CoreTKeyPartitionedCollectionNameDoc()
|
||||
{
|
||||
PartitionKey = "CoreTestPartitionKey";
|
||||
}
|
||||
|
||||
public string PartitionKey { get; set; }
|
||||
}
|
||||
|
||||
public class CRUDTKeyPartitionedCollectionNameAttributeTests : MongoDbTKeyDocumentTestBase<CoreTKeyPartitionedCollectionNameDoc, Guid>
|
||||
{
|
||||
public CRUDTKeyPartitionedCollectionNameAttributeTests(MongoDbTestFixture<CoreTKeyPartitionedCollectionNameDoc, Guid> fixture) : base(fixture)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public override string GetClassName()
|
||||
{
|
||||
return "CoreCRUDTKeyPartitionedCollectionNameAttributeTests";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using System;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class CorePartitionedTKeyTestDocument : TestDoc<Guid>, IPartitionedDocument
|
||||
{
|
||||
public CorePartitionedTKeyTestDocument()
|
||||
{
|
||||
PartitionKey = "CoreTestPartitionKey";
|
||||
}
|
||||
public string PartitionKey { get; set; }
|
||||
}
|
||||
|
||||
public class CRUDTKeyPartitionedTests : MongoDbTKeyDocumentTestBase<CorePartitionedTKeyTestDocument, Guid>
|
||||
{
|
||||
public CRUDTKeyPartitionedTests(MongoDbTestFixture<CorePartitionedTKeyTestDocument, Guid> fixture) : base(fixture)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public override string GetClassName()
|
||||
{
|
||||
return "CoreCRUDTKeyPartitionedTests";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using System;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class CoreTKeyTestDocument : TestDoc<Guid>
|
||||
{
|
||||
}
|
||||
|
||||
public class CRUDTKeyTests : MongoDbTKeyDocumentTestBase<CoreTKeyTestDocument, Guid>
|
||||
{
|
||||
public CRUDTKeyTests(MongoDbTestFixture<CoreTKeyTestDocument, Guid> fixture) : base(fixture)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public override string GetClassName()
|
||||
{
|
||||
return "CreateTKeyTests";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using System;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class CoreTestDocument : TestDoc
|
||||
{
|
||||
}
|
||||
|
||||
public class CRUDTests : MongoDbDocumentTestBase<CoreTestDocument>
|
||||
{
|
||||
public CRUDTests(MongoDbTestFixture<CoreTestDocument, Guid> fixture) : base(fixture)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public override string GetClassName()
|
||||
{
|
||||
return "CRUDTests";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9,13 +9,22 @@
|
||||
<PackageReference Include="Microsoft.Extensions.Identity.Stores" Version="2.0.1" />
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
|
||||
<PackageReference Include="MongoDB.Driver" Version="2.5.0" />
|
||||
<PackageReference Include="MongoDbGenericRepository" Version="1.3.4" />
|
||||
<PackageReference Include="xunit" Version="2.3.1" />
|
||||
<PackageReference Include="xunit.runner.console" Version="2.3.1" />
|
||||
<PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
|
||||
<DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0-beta4-build3742" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\MongoDbGenericRepository\MongoDbGenericRepository.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<Reference Include="System.Configuration">
|
||||
<HintPath>..\..\..\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\System.Configuration.dll</HintPath>
|
||||
</Reference>
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<None Update="App.config">
|
||||
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
|
||||
|
||||
@@ -1,67 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class CreateTestsPartitionedDocument : PartitionedDocument
|
||||
{
|
||||
public CreateTestsPartitionedDocument() : base("TestPartitionKey")
|
||||
{
|
||||
Version = 1;
|
||||
}
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class CreatePartitionedTests : BaseMongoDbRepositoryTests<CreateTestsPartitionedDocument>
|
||||
{
|
||||
private void PartitionedAddOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = new CreateTestsPartitionedDocument();
|
||||
// Act
|
||||
SUT.AddOne(document);
|
||||
// Assert
|
||||
long count = SUT.Count<CreateTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey);
|
||||
Xunit.Assert.Equal(1, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedAddOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = new CreateTestsPartitionedDocument();
|
||||
// Act
|
||||
await SUT.AddOneAsync(document);
|
||||
// Assert
|
||||
long count = SUT.Count<CreateTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey);
|
||||
Assert.Equal(1, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedAddMany()
|
||||
{
|
||||
// Arrange
|
||||
var documents = new List<CreateTestsPartitionedDocument> { new CreateTestsPartitionedDocument(), new CreateTestsPartitionedDocument() };
|
||||
// Act
|
||||
SUT.AddMany(documents);
|
||||
// Assert
|
||||
long count = SUT.Count<CreateTestsPartitionedDocument>(e => e.Id == documents[0].Id || e.Id == documents[1].Id, PartitionKey);
|
||||
Assert.Equal(2, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedAddManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = new List<CreateTestsPartitionedDocument> { new CreateTestsPartitionedDocument(), new CreateTestsPartitionedDocument() };
|
||||
// Act
|
||||
await SUT.AddManyAsync(documents);
|
||||
// Assert
|
||||
long count = SUT.Count<CreateTestsPartitionedDocument>(e => e.Id == documents[0].Id || e.Id == documents[1].Id, PartitionKey);
|
||||
Assert.Equal(2, count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class CreateTestsDocument : Document
|
||||
{
|
||||
public CreateTestsDocument()
|
||||
{
|
||||
Version = 2;
|
||||
}
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class CreateTests : BaseMongoDbRepositoryTests<CreateTestsDocument>
|
||||
{
|
||||
[Fact]
|
||||
public void AddOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = new CreateTestsDocument();
|
||||
// Act
|
||||
SUT.AddOne(document);
|
||||
// Assert
|
||||
long count = SUT.Count<CreateTestsDocument>(e => e.Id == document.Id);
|
||||
Assert.Equal(1, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AddOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = new CreateTestsDocument();
|
||||
// Act
|
||||
await SUT.AddOneAsync(document);
|
||||
// Assert
|
||||
long count = SUT.Count<CreateTestsDocument>(e => e.Id == document.Id);
|
||||
Assert.Equal(1, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddMany()
|
||||
{
|
||||
// Arrange
|
||||
var documents = new List<CreateTestsDocument> { new CreateTestsDocument(), new CreateTestsDocument() };
|
||||
// Act
|
||||
SUT.AddMany(documents);
|
||||
// Assert
|
||||
long count = SUT.Count<CreateTestsDocument>(e => e.Id == documents[0].Id || e.Id == documents[1].Id);
|
||||
Assert.Equal(2, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AddManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = new List<CreateTestsDocument> { new CreateTestsDocument(), new CreateTestsDocument() };
|
||||
// Act
|
||||
await SUT.AddManyAsync(documents);
|
||||
// Assert
|
||||
long count = SUT.Count<CreateTestsDocument>(e => e.Id == documents[0].Id || e.Id == documents[1].Id);
|
||||
Assert.Equal(2, count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,129 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class DeleteTestsPartitionedDocument : PartitionedDocument
|
||||
{
|
||||
public DeleteTestsPartitionedDocument() : base("TestPartitionKey")
|
||||
{
|
||||
Version = 1;
|
||||
}
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class DeletePartitionedTests : BaseMongoDbRepositoryTests<DeleteTestsPartitionedDocument>
|
||||
{
|
||||
[Fact]
|
||||
public void PartitionedDeleteOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.DeleteOne(document);
|
||||
// Assert
|
||||
Assert.Equal(1, result);
|
||||
Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedDeleteOneLinq()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.DeleteOne<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(1, result);
|
||||
Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedDeleteOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.DeleteOneAsync(document);
|
||||
// Assert
|
||||
Assert.Equal(1, result);
|
||||
Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedDeleteOneAsyncLinq()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.DeleteOneAsync<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(1, result);
|
||||
Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedDeleteManyAsyncLinq()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = await SUT.DeleteManyAsync<DeleteTestsPartitionedDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedDeleteManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = await SUT.DeleteManyAsync(documents);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedDeleteManyLinq()
|
||||
{
|
||||
// Arrange
|
||||
var content = "DeleteManyLinqContent";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = SUT.DeleteMany<DeleteTestsPartitionedDocument>(e => e.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.SomeContent == content, PartitionKey));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedDeleteMany()
|
||||
{
|
||||
// Arrange
|
||||
var content = "DeleteManyContent";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = SUT.DeleteMany(documents);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.SomeContent == content, PartitionKey));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,129 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class DeleteTestsDocument : Document
|
||||
{
|
||||
public DeleteTestsDocument()
|
||||
{
|
||||
Version = 2;
|
||||
}
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class DeleteTests : BaseMongoDbRepositoryTests<DeleteTestsDocument>
|
||||
{
|
||||
[Fact]
|
||||
public void DeleteOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.DeleteOne(document);
|
||||
// Assert
|
||||
Assert.Equal(1, result);
|
||||
Assert.False(SUT.Any<DeleteTestsDocument>(e => e.Id == document.Id));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteOneLinq()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.DeleteOne<DeleteTestsDocument>(e => e.Id == document.Id);
|
||||
// Assert
|
||||
Assert.Equal(1, result);
|
||||
Assert.False(SUT.Any<DeleteTestsDocument>(e => e.Id == document.Id));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.DeleteOneAsync(document);
|
||||
// Assert
|
||||
Assert.Equal(1, result);
|
||||
Assert.False(SUT.Any<DeleteTestsDocument>(e => e.Id == document.Id));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteOneAsyncLinq()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.DeleteOneAsync<DeleteTestsDocument>(e => e.Id == document.Id);
|
||||
// Assert
|
||||
Assert.Equal(1, result);
|
||||
Assert.False(SUT.Any<DeleteTestsDocument>(e => e.Id == document.Id));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteManyAsyncLinq()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = await SUT.DeleteManyAsync<DeleteTestsDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent");
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
Assert.False(SUT.Any<DeleteTestsDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = await SUT.DeleteManyAsync(documents);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
Assert.False(SUT.Any<DeleteTestsDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteManyLinq()
|
||||
{
|
||||
// Arrange
|
||||
var content = "DeleteManyLinqContent";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = SUT.DeleteMany<DeleteTestsDocument>(e => e.SomeContent == content);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
Assert.False(SUT.Any<DeleteTestsDocument>(e => e.SomeContent == content));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteMany()
|
||||
{
|
||||
// Arrange
|
||||
var content = "DeleteManyContent";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = SUT.DeleteMany(documents);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
Assert.False(SUT.Any<DeleteTestsDocument>(e => e.SomeContent == content));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
using System;
|
||||
|
||||
namespace CoreIntegrationTests.Infrastructure
|
||||
{
|
||||
/// <summary>
|
||||
/// A class holding global variables.
|
||||
/// </summary>
|
||||
public static class GlobalVariables
|
||||
{
|
||||
/// <summary>
|
||||
/// A random number generator.
|
||||
/// </summary>
|
||||
public static Random Random = new Random();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,727 @@
|
||||
using MongoDbGenericRepository.Models;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Threading.Tasks;
|
||||
using Xunit;
|
||||
|
||||
namespace CoreIntegrationTests.Infrastructure
|
||||
{
|
||||
public abstract class MongoDbDocumentTestBase<T> :
|
||||
IClassFixture<MongoDbTestFixture<T, Guid>>
|
||||
where T: TestDoc, new()
|
||||
{
|
||||
|
||||
private readonly MongoDbTestFixture<T, Guid> _fixture;
|
||||
|
||||
protected MongoDbDocumentTestBase(MongoDbTestFixture<T, Guid> fixture)
|
||||
{
|
||||
_fixture = fixture;
|
||||
var type = CreateTestDocument();
|
||||
DocumentTypeName = type.GetType().FullName;
|
||||
if (type is IPartitionedDocument)
|
||||
{
|
||||
PartitionKey = ((IPartitionedDocument)type).PartitionKey;
|
||||
}
|
||||
_fixture.PartitionKey = PartitionKey;
|
||||
TestClassName = GetClassName();
|
||||
MongoDbConfig.EnsureConfigured();
|
||||
SUT = TestRepository.Instance;
|
||||
}
|
||||
|
||||
protected T CreateTestDocument()
|
||||
{
|
||||
return _fixture.CreateTestDocument();
|
||||
}
|
||||
|
||||
public abstract string GetClassName();
|
||||
|
||||
protected List<T> CreateTestDocuments(int numberOfDocumentsToCreate)
|
||||
{
|
||||
return _fixture.CreateTestDocuments(numberOfDocumentsToCreate);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The partition key for the collection, if any
|
||||
/// </summary>
|
||||
protected string PartitionKey { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// the name of the test class
|
||||
/// </summary>
|
||||
protected string TestClassName { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// The name of the document used for tests
|
||||
/// </summary>
|
||||
protected string DocumentTypeName { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// SUT: System Under Test
|
||||
/// </summary>
|
||||
protected static ITestRepository SUT { get; set; }
|
||||
|
||||
#region Add
|
||||
|
||||
[Fact]
|
||||
public void AddOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = new T();
|
||||
// Act
|
||||
SUT.AddOne<T>(document);
|
||||
// Assert
|
||||
long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T>(e => e.Id.Equals(document.Id))
|
||||
: SUT.Count<T>(e => e.Id.Equals(document.Id), PartitionKey);
|
||||
Assert.True(1 == count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AddOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = new T();
|
||||
// Act
|
||||
await SUT.AddOneAsync<T>(document);
|
||||
// Assert
|
||||
long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T>(e => e.Id.Equals(document.Id))
|
||||
: SUT.Count<T>(e => e.Id.Equals(document.Id), PartitionKey);
|
||||
Assert.True (1 == count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddMany()
|
||||
{
|
||||
// Arrange
|
||||
var documents = new List<T> { new T(), new T() };
|
||||
// Act
|
||||
SUT.AddMany<T>(documents);
|
||||
// Assert
|
||||
long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T>(e => e.Id.Equals(documents[0].Id)
|
||||
|| e.Id.Equals(documents[1].Id))
|
||||
: SUT.Count<T>(e => e.Id.Equals(documents[0].Id)
|
||||
|| e.Id.Equals(documents[1].Id), PartitionKey);
|
||||
Assert.True (2 == count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AddManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = new List<T> { new T(), new T() };
|
||||
// Act
|
||||
await SUT.AddManyAsync<T>(documents);
|
||||
// Assert
|
||||
long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T>(e => e.Id.Equals(documents[0].Id)
|
||||
|| e.Id.Equals(documents[1].Id))
|
||||
: SUT.Count<T>(e => e.Id.Equals(documents[0].Id)
|
||||
|| e.Id.Equals(documents[1].Id), PartitionKey);
|
||||
Assert.True (2 == count, GetTestName());
|
||||
}
|
||||
|
||||
|
||||
#endregion Add
|
||||
|
||||
#region Read
|
||||
|
||||
[Fact]
|
||||
public async Task GetByIdAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = await SUT.GetByIdAsync<T>(document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetById()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = await SUT.GetOneAsync<T>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = SUT.GetOne<T>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetCursor()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var cursor = SUT.GetCursor<T>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
var count = cursor.Count();
|
||||
// Assert
|
||||
Assert.True (1 == count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AnyAsyncReturnsTrue()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = await SUT.AnyAsync<T>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AnyAsyncReturnsFalse()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = await SUT.AnyAsync<T>(x => x.Id.Equals(Guid.NewGuid()), PartitionKey);
|
||||
// Assert
|
||||
Assert.False(result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnyReturnsTrue()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = SUT.Any<T>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnyReturnsFalse()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = SUT.Any<T>(x => x.Id.Equals(Guid.NewGuid()), PartitionKey);
|
||||
// Assert
|
||||
Assert.False(result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetAllAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
var content = GetContent();
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = await SUT.GetAllAsync<T>(x => x.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result.Count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetAll()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
var content = GetContent();
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = SUT.GetAll<T>(x => x.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result.Count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CountAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
var content = GetContent();
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = await SUT.CountAsync<T>(x => x.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Count()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
var content = GetContent();
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = SUT.Count<T>(x => x.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result, GetTestName());
|
||||
}
|
||||
|
||||
#endregion Read
|
||||
|
||||
#region Update
|
||||
|
||||
[Fact]
|
||||
public void UpdateOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
var content = GetContent();
|
||||
document.SomeContent = content;
|
||||
// Act
|
||||
var result = SUT.UpdateOne<T>(document);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
var content = GetContent();
|
||||
document.SomeContent = content;
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync<T>(document);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateOneField()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
var content = GetContent();
|
||||
// Act
|
||||
var result = SUT.UpdateOne<T, string>(document, x => x.SomeContent, content);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
var updatedDocument = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneFieldAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
var content = GetContent();
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync<T, string>(document, x => x.SomeContent, content);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
var updatedDocument = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateOneFieldWithFilter()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
var content = GetContent();
|
||||
// Act
|
||||
var result = SUT.UpdateOne<T, string>(x => x.Id.Equals(document.Id), x => x.SomeContent, content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
var updatedDocument = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneFieldWithFilterAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
var content = GetContent();
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync<T, string>(x => x.Id.Equals(document.Id), x => x.SomeContent, content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
var updatedDocument = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneAsyncWithUpdateDefinition()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
var childrenToAdd = new List<Child>
|
||||
{
|
||||
new Child("testType1", "testValue1"),
|
||||
new Child("testType2", "testValue2")
|
||||
};
|
||||
|
||||
var updateDef = MongoDB.Driver.Builders<T>.Update.AddToSetEach(p => p.Children, childrenToAdd);
|
||||
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync<T>(document, updateDef);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument);
|
||||
Assert.True(childrenToAdd[0].Type == updatedDocument.Children[0].Type, GetTestName());
|
||||
Assert.True(childrenToAdd[0].Value == updatedDocument.Children[0].Value, GetTestName());
|
||||
Assert.True(childrenToAdd[1].Type == updatedDocument.Children[1].Type, GetTestName());
|
||||
Assert.True(childrenToAdd[1].Value == updatedDocument.Children[1].Value, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateOneWithUpdateDefinition()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
var childrenToAdd = new List<Child>
|
||||
{
|
||||
new Child("testType1", "testValue1"),
|
||||
new Child("testType2", "testValue2")
|
||||
};
|
||||
|
||||
var updateDef = MongoDB.Driver.Builders<T>.Update.AddToSetEach(p => p.Children, childrenToAdd);
|
||||
|
||||
// Act
|
||||
var result = SUT.UpdateOne<T>(document, updateDef);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<T>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument);
|
||||
Assert.True(childrenToAdd[0].Type== updatedDocument.Children[0].Type, GetTestName());
|
||||
Assert.True(childrenToAdd[0].Value== updatedDocument.Children[0].Value, GetTestName());
|
||||
Assert.True(childrenToAdd[1].Type== updatedDocument.Children[1].Type, GetTestName());
|
||||
Assert.True(childrenToAdd[1].Value== updatedDocument.Children[1].Value, GetTestName());
|
||||
}
|
||||
|
||||
#endregion Update
|
||||
|
||||
#region Delete
|
||||
|
||||
[Fact]
|
||||
public void DeleteOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = SUT.DeleteOne<T>(document);
|
||||
// Assert
|
||||
Assert.True (1 == result);
|
||||
Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteOneLinq()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = SUT.DeleteOne<T>(e => e.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True (1 == result);
|
||||
Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = await SUT.DeleteOneAsync<T>(document);
|
||||
// Assert
|
||||
Assert.True (1 == result);
|
||||
Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteOneAsyncLinq()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = await SUT.DeleteOneAsync<T>(e => e.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True (1 == result);
|
||||
Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteManyAsyncLinq()
|
||||
{
|
||||
// Arrange
|
||||
var criteria = $"{GetTestName()}.{DocumentTypeName}";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = criteria);
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = await SUT.DeleteManyAsync<T>(e => e.SomeContent == criteria, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result);
|
||||
Assert.False(SUT.Any<T>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var criteria = $"{GetTestName()}.{DocumentTypeName}";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = criteria);
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = await SUT.DeleteManyAsync<T>(documents);
|
||||
// Assert
|
||||
Assert.True(5 == result);
|
||||
Assert.False(SUT.Any<T>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteManyLinq()
|
||||
{
|
||||
// Arrange
|
||||
var criteria = $"{GetTestName()}.{DocumentTypeName}";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = criteria);
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = SUT.DeleteMany<T>(e => e.SomeContent == criteria, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result);
|
||||
Assert.False(SUT.Any<T>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteMany()
|
||||
{
|
||||
// Arrange
|
||||
var criteria = $"{GetTestName()}.{DocumentTypeName}";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = criteria);
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = SUT.DeleteMany<T>(documents);
|
||||
// Assert
|
||||
Assert.True(5 == result);
|
||||
Assert.False(SUT.Any<T>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
#endregion Delete
|
||||
|
||||
#region Project
|
||||
|
||||
[Fact]
|
||||
public async Task ProjectOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var someContent = GetContent();
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocument();
|
||||
document.SomeContent = someContent;
|
||||
document.Nested.SomeDate = someDate;
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = await SUT.ProjectOneAsync<T, MyTestProjection>(
|
||||
x => x.Id.Equals(document.Id),
|
||||
x => new MyTestProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
Assert.True(someContent == result.SomeContent, GetTestName());
|
||||
Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
|
||||
Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProjectOne()
|
||||
{
|
||||
// Arrange
|
||||
var someContent = GetContent();
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocument();
|
||||
document.SomeContent = someContent;
|
||||
document.Nested.SomeDate = someDate;
|
||||
SUT.AddOne<T>(document);
|
||||
// Act
|
||||
var result = SUT.ProjectOne<T, MyTestProjection>(
|
||||
x => x.Id.Equals(document.Id),
|
||||
x => new MyTestProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
Assert.True(someContent == result.SomeContent, GetTestName());
|
||||
Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
|
||||
Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ProjectManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var someContent = GetContent();
|
||||
var someDate = DateTime.UtcNow;
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e =>
|
||||
{
|
||||
e.SomeContent = someContent;
|
||||
e.Nested.SomeDate = someDate;
|
||||
});
|
||||
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = await SUT.ProjectManyAsync<T, MyTestProjection>(
|
||||
x => x.SomeContent == someContent,
|
||||
x => new MyTestProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result.Count, GetTestName());
|
||||
Assert.True(someContent == result.First().SomeContent, GetTestName());
|
||||
Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
|
||||
Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProjectMany()
|
||||
{
|
||||
// Arrange
|
||||
var someContent = GetContent();
|
||||
var someDate = DateTime.UtcNow;
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e =>
|
||||
{
|
||||
e.SomeContent = someContent;
|
||||
e.Nested.SomeDate = someDate;
|
||||
});
|
||||
|
||||
SUT.AddMany<T>(documents);
|
||||
// Act
|
||||
var result = SUT.ProjectMany<T, MyTestProjection>(
|
||||
x => x.SomeContent == someContent,
|
||||
x => new MyTestProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result.Count, GetTestName());
|
||||
Assert.True(someContent == result.First().SomeContent, GetTestName());
|
||||
Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
|
||||
Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
|
||||
}
|
||||
|
||||
#endregion Project
|
||||
|
||||
#region Test Utils
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
private string GetCurrentMethod()
|
||||
{
|
||||
StackTrace st = new StackTrace();
|
||||
StackFrame sf = st.GetFrame(1);
|
||||
|
||||
return sf.GetMethod().Name;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
private string GetParentMethod()
|
||||
{
|
||||
StackTrace st = new StackTrace();
|
||||
StackFrame sf = st.GetFrame(2);
|
||||
var method = sf.GetMethod().DeclaringType.Name;
|
||||
return method;
|
||||
}
|
||||
|
||||
private string GetTestName()
|
||||
{
|
||||
return $"{TestClassName}{PartitionKey}.{GetParentMethod()}";
|
||||
}
|
||||
|
||||
private string GetContent()
|
||||
{
|
||||
return $"{TestClassName}{PartitionKey}.{Guid.NewGuid()}.{GetParentMethod()}";
|
||||
}
|
||||
|
||||
private void Cleanup()
|
||||
{
|
||||
// We drop the collection at the end of each test session.
|
||||
if (!string.IsNullOrEmpty(PartitionKey))
|
||||
{
|
||||
SUT.DropTestCollection<T>(PartitionKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
SUT.DropTestCollection<T>();
|
||||
}
|
||||
}
|
||||
|
||||
#endregion Test Utils
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,728 @@
|
||||
using MongoDbGenericRepository.Models;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Threading.Tasks;
|
||||
using Xunit;
|
||||
|
||||
namespace CoreIntegrationTests.Infrastructure
|
||||
{
|
||||
public abstract class MongoDbTKeyDocumentTestBase<T, TKey> :
|
||||
IClassFixture<MongoDbTestFixture<T, TKey>>
|
||||
where T: TestDoc<TKey>, new()
|
||||
where TKey : IEquatable<TKey>
|
||||
|
||||
{
|
||||
private readonly MongoDbTestFixture<T, TKey> _fixture;
|
||||
|
||||
protected MongoDbTKeyDocumentTestBase(MongoDbTestFixture<T, TKey> fixture)
|
||||
{
|
||||
_fixture = fixture;
|
||||
var type = CreateTestDocument();
|
||||
DocumentTypeName = type.GetType().FullName;
|
||||
if (type is IPartitionedDocument)
|
||||
{
|
||||
PartitionKey = ((IPartitionedDocument)type).PartitionKey;
|
||||
}
|
||||
_fixture.PartitionKey = PartitionKey;
|
||||
TestClassName = GetClassName();
|
||||
MongoDbConfig.EnsureConfigured();
|
||||
SUT = TestRepository.Instance;
|
||||
}
|
||||
|
||||
public abstract string GetClassName();
|
||||
|
||||
public T CreateTestDocument()
|
||||
{
|
||||
return _fixture.CreateTestDocument();
|
||||
}
|
||||
|
||||
public List<T> CreateTestDocuments(int numberOfDocumentsToCreate)
|
||||
{
|
||||
return _fixture.CreateTestDocuments(numberOfDocumentsToCreate);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The partition key for the collection, if any
|
||||
/// </summary>
|
||||
protected string PartitionKey { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// the name of the test class
|
||||
/// </summary>
|
||||
protected string TestClassName { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// The name of the document used for tests
|
||||
/// </summary>
|
||||
protected string DocumentTypeName { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// SUT: System Under Test
|
||||
/// </summary>
|
||||
protected static ITestRepository SUT { get; set; }
|
||||
|
||||
#region Add
|
||||
|
||||
[Fact]
|
||||
public void AddOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = new T();
|
||||
// Act
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Assert
|
||||
long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T, TKey>(e => e.Id.Equals(document.Id))
|
||||
: SUT.Count<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey);
|
||||
Assert.True(1 == count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AddOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = new T();
|
||||
// Act
|
||||
await SUT.AddOneAsync<T, TKey>(document);
|
||||
// Assert
|
||||
long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T, TKey>(e => e.Id.Equals(document.Id))
|
||||
: SUT.Count<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey);
|
||||
Assert.True (1 == count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AddMany()
|
||||
{
|
||||
// Arrange
|
||||
var documents = new List<T> { new T(), new T() };
|
||||
// Act
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Assert
|
||||
long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T, TKey>(e => e.Id.Equals(documents[0].Id)
|
||||
|| e.Id.Equals(documents[1].Id))
|
||||
: SUT.Count<T, TKey>(e => e.Id.Equals(documents[0].Id)
|
||||
|| e.Id.Equals(documents[1].Id), PartitionKey);
|
||||
Assert.True (2 == count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AddManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = new List<T> { new T(), new T() };
|
||||
// Act
|
||||
await SUT.AddManyAsync<T, TKey>(documents);
|
||||
// Assert
|
||||
long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T, TKey>(e => e.Id.Equals(documents[0].Id)
|
||||
|| e.Id.Equals(documents[1].Id))
|
||||
: SUT.Count<T, TKey>(e => e.Id.Equals(documents[0].Id)
|
||||
|| e.Id.Equals(documents[1].Id), PartitionKey);
|
||||
Assert.True (2 == count, GetTestName());
|
||||
}
|
||||
|
||||
|
||||
#endregion Add
|
||||
|
||||
#region Read
|
||||
|
||||
[Fact]
|
||||
public async Task GetByIdAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = await SUT.GetByIdAsync<T, TKey>(document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetById()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = await SUT.GetOneAsync<T, TKey>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = SUT.GetOne<T, TKey>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetCursor()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var cursor = SUT.GetCursor<T, TKey>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
var count = cursor.Count();
|
||||
// Assert
|
||||
Assert.True (1 == count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AnyAsyncReturnsTrue()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = await SUT.AnyAsync<T, TKey>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AnyAsyncReturnsFalse()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = await SUT.AnyAsync<T, TKey>(x => x.Id.Equals(document.Init<TKey>()), PartitionKey);
|
||||
// Assert
|
||||
Assert.False(result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnyReturnsTrue()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = SUT.Any<T, TKey>(x => x.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnyReturnsFalse()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = SUT.Any<T, TKey>(x => x.Id.Equals(document.Init<TKey>()), PartitionKey);
|
||||
// Assert
|
||||
Assert.False(result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetAllAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
var content = GetContent();
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = await SUT.GetAllAsync<T, TKey>(x => x.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result.Count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetAll()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
var content = GetContent();
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = SUT.GetAll<T, TKey>(x => x.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result.Count, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CountAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
var content = GetContent();
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = await SUT.CountAsync<T, TKey>(x => x.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Count()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
var content = GetContent();
|
||||
documents.ForEach(e => e.SomeContent = content);
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = SUT.Count<T, TKey>(x => x.SomeContent == content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result, GetTestName());
|
||||
}
|
||||
|
||||
#endregion Read
|
||||
|
||||
#region Update
|
||||
|
||||
[Fact]
|
||||
public void UpdateOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
var content = GetContent();
|
||||
document.SomeContent = content;
|
||||
// Act
|
||||
var result = SUT.UpdateOne<T, TKey>(document);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
var content = GetContent();
|
||||
document.SomeContent = content;
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync<T, TKey>(document);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateOneField()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
var content = GetContent();
|
||||
// Act
|
||||
var result = SUT.UpdateOne<T, TKey, string>(document, x => x.SomeContent, content);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneFieldAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
var content = GetContent();
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync<T, TKey, string>(document, x => x.SomeContent, content);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateOneFieldWithFilter()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
var content = GetContent();
|
||||
// Act
|
||||
var result = SUT.UpdateOne<T, TKey, string>(x => x.Id.Equals(document.Id), x => x.SomeContent, content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneFieldWithFilterAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
var content = GetContent();
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync<T, TKey, string>(x => x.Id.Equals(document.Id), x => x.SomeContent, content, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result, GetTestName());
|
||||
var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument, GetTestName());
|
||||
Assert.True(content == updatedDocument.SomeContent, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneAsyncWithUpdateDefinition()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
var childrenToAdd = new List<Child>
|
||||
{
|
||||
new Child("testType1", "testValue1"),
|
||||
new Child("testType2", "testValue2")
|
||||
};
|
||||
|
||||
var updateDef = MongoDB.Driver.Builders<T>.Update.AddToSetEach(p => p.Children, childrenToAdd);
|
||||
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync<T, TKey>(document, updateDef);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument);
|
||||
Assert.True(childrenToAdd[0].Type == updatedDocument.Children[0].Type, GetTestName());
|
||||
Assert.True(childrenToAdd[0].Value == updatedDocument.Children[0].Value, GetTestName());
|
||||
Assert.True(childrenToAdd[1].Type == updatedDocument.Children[1].Type, GetTestName());
|
||||
Assert.True(childrenToAdd[1].Value == updatedDocument.Children[1].Value, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UpdateOneWithUpdateDefinition()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
var childrenToAdd = new List<Child>
|
||||
{
|
||||
new Child("testType1", "testValue1"),
|
||||
new Child("testType2", "testValue2")
|
||||
};
|
||||
|
||||
var updateDef = MongoDB.Driver.Builders<T>.Update.AddToSetEach(p => p.Children, childrenToAdd);
|
||||
|
||||
// Act
|
||||
var result = SUT.UpdateOne<T, TKey>(document, updateDef);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
|
||||
Assert.True(null != updatedDocument);
|
||||
Assert.True(childrenToAdd[0].Type== updatedDocument.Children[0].Type, GetTestName());
|
||||
Assert.True(childrenToAdd[0].Value== updatedDocument.Children[0].Value, GetTestName());
|
||||
Assert.True(childrenToAdd[1].Type== updatedDocument.Children[1].Type, GetTestName());
|
||||
Assert.True(childrenToAdd[1].Value== updatedDocument.Children[1].Value, GetTestName());
|
||||
}
|
||||
|
||||
#endregion Update
|
||||
|
||||
#region Delete
|
||||
|
||||
[Fact]
|
||||
public void DeleteOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = SUT.DeleteOne<T, TKey>(document);
|
||||
// Assert
|
||||
Assert.True (1 == result);
|
||||
Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteOneLinq()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = SUT.DeleteOne<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True (1 == result);
|
||||
Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = await SUT.DeleteOneAsync<T, TKey>(document);
|
||||
// Assert
|
||||
Assert.True (1 == result);
|
||||
Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteOneAsyncLinq()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = await SUT.DeleteOneAsync<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey);
|
||||
// Assert
|
||||
Assert.True (1 == result);
|
||||
Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteManyAsyncLinq()
|
||||
{
|
||||
// Arrange
|
||||
var criteria = $"{GetTestName()}.{DocumentTypeName}";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = criteria);
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = await SUT.DeleteManyAsync<T, TKey>(e => e.SomeContent == criteria, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result);
|
||||
Assert.False(SUT.Any<T, TKey>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task DeleteManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var criteria = $"{GetTestName()}.{DocumentTypeName}";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = criteria);
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = await SUT.DeleteManyAsync<T, TKey>(documents);
|
||||
// Assert
|
||||
Assert.True(5 == result);
|
||||
Assert.False(SUT.Any<T, TKey>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteManyLinq()
|
||||
{
|
||||
// Arrange
|
||||
var criteria = $"{GetTestName()}.{DocumentTypeName}";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = criteria);
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = SUT.DeleteMany<T, TKey>(e => e.SomeContent == criteria, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result);
|
||||
Assert.False(SUT.Any<T, TKey>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeleteMany()
|
||||
{
|
||||
// Arrange
|
||||
var criteria = $"{GetTestName()}.{DocumentTypeName}";
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = criteria);
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = SUT.DeleteMany<T, TKey>(documents);
|
||||
// Assert
|
||||
Assert.True(5 == result);
|
||||
Assert.False(SUT.Any<T, TKey>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
|
||||
}
|
||||
|
||||
#endregion Delete
|
||||
|
||||
#region Project
|
||||
|
||||
[Fact]
|
||||
public async Task ProjectOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var someContent = GetContent();
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocument();
|
||||
document.SomeContent = someContent;
|
||||
document.Nested.SomeDate = someDate;
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = await SUT.ProjectOneAsync<T, MyTestProjection, TKey>(
|
||||
x => x.Id.Equals(document.Id),
|
||||
x => new MyTestProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
Assert.True(someContent == result.SomeContent, GetTestName());
|
||||
Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
|
||||
Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProjectOne()
|
||||
{
|
||||
// Arrange
|
||||
var someContent = GetContent();
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocument();
|
||||
document.SomeContent = someContent;
|
||||
document.Nested.SomeDate = someDate;
|
||||
SUT.AddOne<T, TKey>(document);
|
||||
// Act
|
||||
var result = SUT.ProjectOne<T, MyTestProjection, TKey>(
|
||||
x => x.Id.Equals(document.Id),
|
||||
x => new MyTestProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.True(null != result, GetTestName());
|
||||
Assert.True(someContent == result.SomeContent, GetTestName());
|
||||
Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
|
||||
Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ProjectManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
var someContent = GetContent();
|
||||
var someDate = DateTime.UtcNow;
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e =>
|
||||
{
|
||||
e.SomeContent = someContent;
|
||||
e.Nested.SomeDate = someDate;
|
||||
});
|
||||
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = await SUT.ProjectManyAsync<T, MyTestProjection, TKey>(
|
||||
x => x.SomeContent == someContent,
|
||||
x => new MyTestProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result.Count, GetTestName());
|
||||
Assert.True(someContent == result.First().SomeContent, GetTestName());
|
||||
Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
|
||||
Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProjectMany()
|
||||
{
|
||||
// Arrange
|
||||
var someContent = GetContent();
|
||||
var someDate = DateTime.UtcNow;
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e =>
|
||||
{
|
||||
e.SomeContent = someContent;
|
||||
e.Nested.SomeDate = someDate;
|
||||
});
|
||||
|
||||
SUT.AddMany<T, TKey>(documents);
|
||||
// Act
|
||||
var result = SUT.ProjectMany<T, MyTestProjection, TKey>(
|
||||
x => x.SomeContent == someContent,
|
||||
x => new MyTestProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.True(5 == result.Count, GetTestName());
|
||||
Assert.True(someContent == result.First().SomeContent, GetTestName());
|
||||
Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
|
||||
Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
|
||||
}
|
||||
|
||||
#endregion Project
|
||||
|
||||
#region Test Utils
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
private string GetCurrentMethod()
|
||||
{
|
||||
StackTrace st = new StackTrace();
|
||||
StackFrame sf = st.GetFrame(1);
|
||||
|
||||
return sf.GetMethod().Name;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
private string GetParentMethod()
|
||||
{
|
||||
StackTrace st = new StackTrace();
|
||||
StackFrame sf = st.GetFrame(2);
|
||||
var method = sf.GetMethod().DeclaringType.Name;
|
||||
return method;
|
||||
}
|
||||
|
||||
private string GetTestName()
|
||||
{
|
||||
return $"{TestClassName}{PartitionKey}.{GetParentMethod()}";
|
||||
}
|
||||
|
||||
private string GetContent()
|
||||
{
|
||||
return $"{TestClassName}{PartitionKey}.{Guid.NewGuid()}.{GetParentMethod()}";
|
||||
}
|
||||
|
||||
private void Cleanup()
|
||||
{
|
||||
// We drop the collection at the end of each test session.
|
||||
if (!string.IsNullOrEmpty(PartitionKey))
|
||||
{
|
||||
SUT.DropTestCollection<T>(PartitionKey);
|
||||
}
|
||||
else
|
||||
{
|
||||
SUT.DropTestCollection<T>();
|
||||
}
|
||||
}
|
||||
|
||||
#endregion Test Utils
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
using MongoDbGenericRepository;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
|
||||
|
||||
namespace CoreIntegrationTests.Infrastructure
|
||||
{
|
||||
|
||||
public class MongoDbTestFixture<T, TKey> : IDisposable
|
||||
where T : IDocument<TKey>, new()
|
||||
where TKey : IEquatable<TKey>
|
||||
{
|
||||
|
||||
public IMongoDbContext Context;
|
||||
|
||||
public MongoDbTestFixture()
|
||||
{
|
||||
DocsToDelete = new ConcurrentBag<T>();
|
||||
}
|
||||
|
||||
public string PartitionKey { get; set; }
|
||||
|
||||
public ConcurrentBag<T> DocsToDelete { get; set; }
|
||||
|
||||
public virtual void Dispose()
|
||||
{
|
||||
var docIds = DocsToDelete.ToList().Select(e => e.Id);
|
||||
if (docIds.Any())
|
||||
{
|
||||
TestRepository.Instance.DeleteMany<T, TKey>(e => docIds.Contains(e.Id));
|
||||
}
|
||||
}
|
||||
|
||||
public T CreateTestDocument()
|
||||
{
|
||||
var doc = new T();
|
||||
DocsToDelete.Add(doc);
|
||||
return doc;
|
||||
}
|
||||
|
||||
public List<T> CreateTestDocuments(int numberOfDocumentsToCreate)
|
||||
{
|
||||
var docs = new List<T>();
|
||||
for (var i = 0; i < numberOfDocumentsToCreate; i++)
|
||||
{
|
||||
docs.Add(new T());
|
||||
DocsToDelete.Add(docs.Last());
|
||||
}
|
||||
return docs;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
using System;
|
||||
|
||||
namespace CoreIntegrationTests.Infrastructure
|
||||
{
|
||||
// Thanks BlueRaja - Danny Pflughoeft https://stackoverflow.com/a/13095144/5103354
|
||||
/// <summary>
|
||||
/// Extensions for the random number generator <see cref="Random"/>
|
||||
/// </summary>
|
||||
public static class RandomExtensions
|
||||
{
|
||||
|
||||
/// <summary>
|
||||
/// Returns a random long from min (inclusive) to max (exclusive)
|
||||
/// </summary>
|
||||
/// <param name="random">The given random instance</param>
|
||||
/// <param name="min">The inclusive minimum bound</param>
|
||||
/// <param name="max">The exclusive maximum bound. Must be greater than min</param>
|
||||
public static long NextLong(this Random random, long min, long max)
|
||||
{
|
||||
if (max <= min)
|
||||
throw new ArgumentOutOfRangeException("max", "max must be > min!");
|
||||
|
||||
//Working with ulong so that modulo works correctly with values > long.MaxValue
|
||||
ulong uRange = (ulong)(max - min);
|
||||
|
||||
//Prevent a modulo bias; see https://stackoverflow.com/a/10984975/238419
|
||||
//for more information.
|
||||
//In the worst case, the expected number of calls is 2 (though usually it's
|
||||
//much closer to 1) so this loop doesn't really hurt performance at all.
|
||||
ulong ulongRand;
|
||||
do
|
||||
{
|
||||
byte[] buf = new byte[8];
|
||||
random.NextBytes(buf);
|
||||
ulongRand = (ulong)BitConverter.ToInt64(buf, 0);
|
||||
} while (ulongRand > ulong.MaxValue - ((ulong.MaxValue % uRange) + 1) % uRange);
|
||||
|
||||
return (long)(ulongRand % uRange) + min;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns a random long from 0 (inclusive) to max (exclusive)
|
||||
/// </summary>
|
||||
/// <param name="random">The given random instance</param>
|
||||
/// <param name="max">The exclusive maximum bound. Must be greater than 0</param>
|
||||
public static long NextLong(this Random random, long max)
|
||||
{
|
||||
return random.NextLong(0, max);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns a random long over all possible values of long (except long.MaxValue, similar to
|
||||
/// random.Next())
|
||||
/// </summary>
|
||||
/// <param name="random">The given random instance</param>
|
||||
public static long NextLong(this Random random)
|
||||
{
|
||||
return random.NextLong(long.MinValue, long.MaxValue);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
using MongoDB.Bson.Serialization.Attributes;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace CoreIntegrationTests.Infrastructure
|
||||
{
|
||||
public class ProjectedGroup
|
||||
{
|
||||
public int Key { get; set; }
|
||||
public List<string> Content { get; set; }
|
||||
}
|
||||
|
||||
public class MyTestProjection
|
||||
{
|
||||
public string SomeContent { get; set; }
|
||||
public DateTime SomeDate { get; set; }
|
||||
}
|
||||
|
||||
public class Nested
|
||||
{
|
||||
public DateTime SomeDate { get; set; }
|
||||
}
|
||||
|
||||
public class Child
|
||||
{
|
||||
public Child(string type, string value)
|
||||
{
|
||||
Type = type;
|
||||
Value = value;
|
||||
}
|
||||
|
||||
public string Type { get; set; }
|
||||
public string Value { get; set; }
|
||||
}
|
||||
|
||||
public class TestDoc : Document
|
||||
{
|
||||
public TestDoc()
|
||||
{
|
||||
Version = 2;
|
||||
Nested = new Nested
|
||||
{
|
||||
SomeDate = DateTime.UtcNow
|
||||
};
|
||||
Children = new List<Child>();
|
||||
}
|
||||
|
||||
public string SomeContent { get; set; }
|
||||
|
||||
public int GroupingKey { get; set; }
|
||||
|
||||
public Nested Nested { get; set; }
|
||||
|
||||
public List<Child> Children { get; set; }
|
||||
|
||||
}
|
||||
|
||||
public class TestDoc<TKey> : IDocument<TKey>
|
||||
where TKey : IEquatable<TKey>
|
||||
{
|
||||
[BsonId]
|
||||
public TKey Id { get; set; }
|
||||
public int Version { get; set; }
|
||||
|
||||
public TestDoc()
|
||||
{
|
||||
InitializeFields();
|
||||
Version = 2;
|
||||
Nested = new Nested
|
||||
{
|
||||
SomeDate = DateTime.UtcNow
|
||||
};
|
||||
Children = new List<Child>();
|
||||
}
|
||||
|
||||
public string SomeContent { get; set; }
|
||||
|
||||
public Nested Nested { get; set; }
|
||||
|
||||
public List<Child> Children { get; set; }
|
||||
|
||||
public TId Init<TId>()
|
||||
{
|
||||
var idTypeName = typeof(TKey).Name;
|
||||
switch (idTypeName)
|
||||
{
|
||||
case "Guid":
|
||||
return (TId)(object)Guid.NewGuid();
|
||||
case "Int16":
|
||||
return (TId)(object)GlobalVariables.Random.Next(1, short.MaxValue);
|
||||
case "Int32":
|
||||
return (TId)(object)GlobalVariables.Random.Next(1, int.MaxValue);
|
||||
case "Int64":
|
||||
return (TId)(object)(GlobalVariables.Random.NextLong(1, long.MaxValue));
|
||||
case "String":
|
||||
return (TId)(object)Guid.NewGuid().ToString();
|
||||
default:
|
||||
throw new NotSupportedException($"{idTypeName} is not supported.");
|
||||
}
|
||||
}
|
||||
|
||||
private void InitializeFields()
|
||||
{
|
||||
Id = Init<TKey>();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,140 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class ProjectTestsPartitionedDocument : PartitionedDocument
|
||||
{
|
||||
public ProjectTestsPartitionedDocument() : base("TestPartitionKey")
|
||||
{
|
||||
Version = 2;
|
||||
Nested = new Nested
|
||||
{
|
||||
SomeDate = DateTime.UtcNow
|
||||
};
|
||||
}
|
||||
|
||||
public string SomeContent { get; set; }
|
||||
|
||||
public Nested Nested { get; set; }
|
||||
}
|
||||
|
||||
public class ProjectPartitionedTests : BaseMongoDbRepositoryTests<ProjectTestsPartitionedDocument>
|
||||
{
|
||||
[Fact]
|
||||
public async Task PartitionedProjectOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
const string someContent = "ProjectOneAsyncContent";
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocument();
|
||||
document.SomeContent = someContent;
|
||||
document.Nested.SomeDate = someDate;
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.ProjectOneAsync<ProjectTestsPartitionedDocument, MyProjection>(
|
||||
x => x.Id == document.Id,
|
||||
x => new MyProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
Assert.Equal(someContent, result.SomeContent);
|
||||
Assert.Equal(someDate.Minute, result.SomeDate.Minute);
|
||||
Assert.Equal(someDate.Second, result.SomeDate.Second);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedProjectOne()
|
||||
{
|
||||
// Arrange
|
||||
const string someContent = "ProjectOneContent";
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocument();
|
||||
document.SomeContent = someContent;
|
||||
document.Nested.SomeDate = someDate;
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.ProjectOne<ProjectTestsPartitionedDocument, MyProjection>(
|
||||
x => x.Id == document.Id,
|
||||
x => new MyProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
Assert.Equal(someContent, result.SomeContent);
|
||||
Assert.Equal(someDate.Minute, result.SomeDate.Minute);
|
||||
Assert.Equal(someDate.Second, result.SomeDate.Second);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedProjectManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
const string someContent = "ProjectManyAsyncContent";
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocuments(5);
|
||||
document.ForEach(e =>
|
||||
{
|
||||
e.SomeContent = someContent;
|
||||
e.Nested.SomeDate = someDate;
|
||||
});
|
||||
|
||||
SUT.AddMany(document);
|
||||
// Act
|
||||
var result = await SUT.ProjectManyAsync<ProjectTestsPartitionedDocument, MyProjection>(
|
||||
x => x.SomeContent == someContent,
|
||||
x => new MyProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(5, result.Count);
|
||||
Assert.Equal(someContent, result.First().SomeContent);
|
||||
Assert.Equal(someDate.Minute, result.First().SomeDate.Minute);
|
||||
Assert.Equal(someDate.Second, result.First().SomeDate.Second);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedProjectMany()
|
||||
{
|
||||
// Arrange
|
||||
const string someContent = "ProjectManyContent";
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocuments(5);
|
||||
document.ForEach(e =>
|
||||
{
|
||||
e.SomeContent = someContent;
|
||||
e.Nested.SomeDate = someDate;
|
||||
});
|
||||
|
||||
SUT.AddMany(document);
|
||||
// Act
|
||||
var result = SUT.ProjectMany<ProjectTestsPartitionedDocument, MyProjection>(
|
||||
x => x.SomeContent == someContent,
|
||||
x => new MyProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
},
|
||||
PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(5, result.Count);
|
||||
Assert.Equal(someContent, result.First().SomeContent);
|
||||
Assert.Equal(someDate.Minute, result.First().SomeDate.Minute);
|
||||
Assert.Equal(someDate.Second, result.First().SomeDate.Second);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,149 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class Nested
|
||||
{
|
||||
public DateTime SomeDate { get; set; }
|
||||
}
|
||||
|
||||
public class MyProjection
|
||||
{
|
||||
public DateTime SomeDate { get; set; }
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class ProjectTestsDocument : Document
|
||||
{
|
||||
public ProjectTestsDocument()
|
||||
{
|
||||
Version = 2;
|
||||
Nested = new Nested
|
||||
{
|
||||
SomeDate = DateTime.UtcNow
|
||||
};
|
||||
}
|
||||
|
||||
public string SomeContent { get; set; }
|
||||
|
||||
public Nested Nested { get; set; }
|
||||
}
|
||||
|
||||
public class ProjectTests : BaseMongoDbRepositoryTests<ProjectTestsDocument>
|
||||
{
|
||||
|
||||
|
||||
[Fact]
|
||||
public async Task ProjectOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
const string someContent = "ProjectOneAsyncContent";
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocument();
|
||||
document.SomeContent = someContent;
|
||||
document.Nested.SomeDate = someDate;
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.ProjectOneAsync<ProjectTestsDocument, MyProjection>(
|
||||
x => x.Id == document.Id,
|
||||
x => new MyProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
});
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
Assert.Equal(someContent, result.SomeContent);
|
||||
Assert.Equal(someDate.Minute, result.SomeDate.Minute);
|
||||
Assert.Equal(someDate.Second, result.SomeDate.Second);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProjectOne()
|
||||
{
|
||||
// Arrange
|
||||
const string someContent = "ProjectOneContent";
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocument();
|
||||
document.SomeContent = someContent;
|
||||
document.Nested.SomeDate = someDate;
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.ProjectOne<ProjectTestsDocument, MyProjection>(
|
||||
x => x.Id == document.Id,
|
||||
x => new MyProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
});
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
Assert.Equal(someContent, result.SomeContent);
|
||||
Assert.Equal(someDate.Minute, result.SomeDate.Minute);
|
||||
Assert.Equal(someDate.Second, result.SomeDate.Second);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ProjectManyAsync()
|
||||
{
|
||||
// Arrange
|
||||
const string someContent = "ProjectManyAsyncContent";
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocuments(5);
|
||||
document.ForEach(e =>
|
||||
{
|
||||
e.SomeContent = someContent;
|
||||
e.Nested.SomeDate = someDate;
|
||||
});
|
||||
|
||||
SUT.AddMany(document);
|
||||
// Act
|
||||
var result = await SUT.ProjectManyAsync<ProjectTestsDocument, MyProjection>(
|
||||
x => x.SomeContent == someContent,
|
||||
x => new MyProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
});
|
||||
// Assert
|
||||
Assert.Equal(5, result.Count);
|
||||
Assert.Equal(someContent, result.First().SomeContent);
|
||||
Assert.Equal(someDate.Minute, result.First().SomeDate.Minute);
|
||||
Assert.Equal(someDate.Second, result.First().SomeDate.Second);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProjectMany()
|
||||
{
|
||||
// Arrange
|
||||
const string someContent = "ProjectManyContent";
|
||||
var someDate = DateTime.UtcNow;
|
||||
var document = CreateTestDocuments(5);
|
||||
document.ForEach(e =>
|
||||
{
|
||||
e.SomeContent = someContent;
|
||||
e.Nested.SomeDate = someDate;
|
||||
});
|
||||
|
||||
SUT.AddMany(document);
|
||||
// Act
|
||||
var result = SUT.ProjectMany<ProjectTestsDocument, MyProjection>(
|
||||
x => x.SomeContent == someContent,
|
||||
x => new MyProjection
|
||||
{
|
||||
SomeContent = x.SomeContent,
|
||||
SomeDate = x.Nested.SomeDate
|
||||
});
|
||||
// Assert
|
||||
Assert.Equal(5, result.Count);
|
||||
Assert.Equal(someContent, result.First().SomeContent);
|
||||
Assert.Equal(someDate.Minute, result.First().SomeDate.Minute);
|
||||
Assert.Equal(someDate.Second, result.First().SomeDate.Second);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,181 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class ReadTestsPartitionedDocument : PartitionedDocument
|
||||
{
|
||||
public ReadTestsPartitionedDocument() : base("TestPartitionKey")
|
||||
{
|
||||
Version = 1;
|
||||
}
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class ReadPartitionedTests : BaseMongoDbRepositoryTests<ReadTestsPartitionedDocument>
|
||||
{
|
||||
[Fact]
|
||||
public async Task PartitionedGetByIdAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.GetByIdAsync<ReadTestsPartitionedDocument>(document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedGetById()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.GetById<ReadTestsPartitionedDocument>(document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedGetOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.GetOneAsync<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedGetOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.GetOne<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedGetCursor()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var cursor = SUT.GetCursor<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
|
||||
var count = cursor.Count();
|
||||
// Assert
|
||||
Assert.Equal(1, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedAnyAsyncReturnsTrue()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.AnyAsync<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedAnyAsyncReturnsFalse()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.AnyAsync<ReadTestsPartitionedDocument>(x => x.Id == Guid.NewGuid(), PartitionKey);
|
||||
// Assert
|
||||
Assert.False(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedAnyReturnsTrue()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.Any<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedAnyReturnsFalse()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.Any<ReadTestsPartitionedDocument>(x => x.Id == Guid.NewGuid(), PartitionKey);
|
||||
// Assert
|
||||
Assert.False(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedGetAllAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "GetAllAsyncContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = await SUT.GetAllAsync<ReadTestsPartitionedDocument>(x => x.SomeContent == "GetAllAsyncContent", PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(5, result.Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedGetAll()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "GetAllContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = SUT.GetAll<ReadTestsPartitionedDocument>(x => x.SomeContent == "GetAllContent", PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(5, result.Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedCountAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "CountAsyncContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = await SUT.CountAsync<ReadTestsPartitionedDocument>(x => x.SomeContent == "CountAsyncContent", PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartitionedCount()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "CountContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = SUT.Count<ReadTestsPartitionedDocument>(x => x.SomeContent == "CountContent", PartitionKey);
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,181 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class ReadTestsDocument : Document
|
||||
{
|
||||
public ReadTestsDocument()
|
||||
{
|
||||
Version = 2;
|
||||
}
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class ReadTests : BaseMongoDbRepositoryTests<ReadTestsDocument>
|
||||
{
|
||||
[Fact]
|
||||
public async Task GetByIdAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.GetByIdAsync<ReadTestsDocument>(document.Id);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetById()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.GetById<ReadTestsDocument>(document.Id);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.GetOneAsync<ReadTestsDocument>(x => x.Id == document.Id);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.GetOne<ReadTestsDocument>(x => x.Id == document.Id);
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetCursor()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var cursor = SUT.GetCursor<ReadTestsDocument>(x => x.Id == document.Id);
|
||||
var count = cursor.Count();
|
||||
// Assert
|
||||
Assert.Equal(1, count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AnyAsyncReturnsTrue()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.AnyAsync<ReadTestsDocument>(x => x.Id == document.Id);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AnyAsyncReturnsFalse()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = await SUT.AnyAsync<ReadTestsDocument>(x => x.Id == Guid.NewGuid());
|
||||
// Assert
|
||||
Assert.False(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnyReturnsTrue()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.Any<ReadTestsDocument>(x => x.Id == document.Id);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnyReturnsFalse()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
// Act
|
||||
var result = SUT.Any<ReadTestsDocument>(x => x.Id == Guid.NewGuid());
|
||||
// Assert
|
||||
Assert.False(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetAllAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "GetAllAsyncContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = await SUT.GetAllAsync<ReadTestsDocument>(x => x.SomeContent == "GetAllAsyncContent");
|
||||
// Assert
|
||||
Assert.Equal(5, result.Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetAll()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "GetAllContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = SUT.GetAll<ReadTestsDocument>(x => x.SomeContent == "GetAllContent");
|
||||
// Assert
|
||||
Assert.Equal(5, result.Count);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CountAsync()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "CountAsyncContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = await SUT.CountAsync<ReadTestsDocument>(x => x.SomeContent == "CountAsyncContent");
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Count()
|
||||
{
|
||||
// Arrange
|
||||
var documents = CreateTestDocuments(5);
|
||||
documents.ForEach(e => e.SomeContent = "CountContent");
|
||||
SUT.AddMany(documents);
|
||||
// Act
|
||||
var result = SUT.Count<ReadTestsDocument>(x => x.SomeContent == "CountContent");
|
||||
// Assert
|
||||
Assert.Equal(5, result);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class UpdateTestsPartitionedDocument : PartitionedDocument
|
||||
{
|
||||
public UpdateTestsPartitionedDocument() : base("TestPartitionKey")
|
||||
{
|
||||
Version = 2;
|
||||
}
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class UpdatePartitionedTests : BaseMongoDbRepositoryTests<UpdateTestsPartitionedDocument>
|
||||
{
|
||||
[Fact]
|
||||
public void PartitionedUpdateOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
document.SomeContent = "UpdateOneContent";
|
||||
// Act
|
||||
var result = SUT.UpdateOne(document);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, PartitionKey);
|
||||
Assert.NotNull(updatedDocument);
|
||||
Assert.Equal("UpdateOneContent", updatedDocument.SomeContent);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PartitionedUpdateOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
document.SomeContent = "UpdateOneAsyncContent";
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync(document);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, PartitionKey);
|
||||
Assert.NotNull(updatedDocument);
|
||||
Assert.Equal("UpdateOneAsyncContent", updatedDocument.SomeContent);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
using CoreIntegrationTests.Infrastructure;
|
||||
using MongoDbGenericRepository.Models;
|
||||
using Xunit;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace CoreIntegrationTests
|
||||
{
|
||||
public class UpdateTestsDocument : Document
|
||||
{
|
||||
public UpdateTestsDocument()
|
||||
{
|
||||
Version = 2;
|
||||
}
|
||||
public string SomeContent { get; set; }
|
||||
}
|
||||
|
||||
public class UpdateTests : BaseMongoDbRepositoryTests<UpdateTestsDocument>
|
||||
{
|
||||
[Fact]
|
||||
public void UpdateOne()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
document.SomeContent = "UpdateOneContent";
|
||||
// Act
|
||||
var result = SUT.UpdateOne(document);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
|
||||
Assert.NotNull(updatedDocument);
|
||||
Assert.Equal("UpdateOneContent", updatedDocument.SomeContent);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UpdateOneAsync()
|
||||
{
|
||||
// Arrange
|
||||
var document = CreateTestDocument();
|
||||
SUT.AddOne(document);
|
||||
document.SomeContent = "UpdateOneAsyncContent";
|
||||
// Act
|
||||
var result = await SUT.UpdateOneAsync(document);
|
||||
// Assert
|
||||
Assert.True(result);
|
||||
var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
|
||||
Assert.NotNull(updatedDocument);
|
||||
Assert.Equal("UpdateOneAsyncContent", updatedDocument.SomeContent);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user