public void CreateSelectionStatement_PageWithoutOrder_ThrowsException()
{
var transactionSelection = Query
.Select <DataRow>(
row => row.FakeDataId,
row => row.NormalColumn,
row => row.NullableColumn,
row => row.NullableValueColumn,
row => row.ValueColumn,
row => row.AnotherColumn,
row => row.AnotherValueColumn)
.From(
set => set.InnerJoin(row => row.FakeDataId, row => row.Related.FakeDataId)
.InnerJoin(row => row.Related.RelatedId, row => row.DependencyEntity.ComplexEntityId)
.InnerJoin(row => row.FakeDataId, row => row.OtherAlias.FakeDataId)
.InnerJoin(row => row.OtherAlias.RelatedId, row => row.RelatedDependency.ComplexEntityId)
.InnerJoin(row => row.FakeDataId, row => row.RelatedAlias.FakeDataId)
.LeftJoin <SubDataRow>(row => row.FakeDataId, row => row.FakeSubDataId))
.Where(
set => set.AreEqual(row => row.ValueColumn, 2)
.AreEqual(row => row.NullableColumn, "CouldHaveBeenNull")
.AreEqual(row => row.NullableValueColumn, null)
.Between(row => row.FakeDataId, 10, 20)
.GreaterThanOrEqualTo(row => row.NormalColumn, "Greater")
.LessThanOrEqualTo(row => row.AnotherColumn, "Less")
.Include(row => row.AnotherValueColumn, 5, 10, 15, 20))
.Seek(set => set.Skip(5).Take(5));
var definitionProvider = new DataAnnotationsDefinitionProvider();
var target = new PostgreSqlAdapter(definitionProvider);
target.CreateSelectionStatement(transactionSelection);
}
public void ExecuteQuery_SqlQuery_ExecutesQueryWithExpectedResults()
{
var providerName = "System.Data.SqlClient";
#if !NET472
if (DbProviderFactories.GetProviderInvariantNames().Any(s => string.Equals(s, providerName, StringComparison.Ordinal)) == false)
{
Trace.WriteLine($"Registering {providerName} factory");
DbProviderFactories.RegisterFactory(providerName, SqlClientFactory.Instance);
}
#endif
var connectionString = ConfigurationRoot.GetConnectionString("MasterDatabase");
var definitionProvider = new DataAnnotationsDefinitionProvider();
var repositoryAdapter = new TransactSqlAdapter(definitionProvider);
using (var target = new DatabaseContext(connectionString, providerName, repositoryAdapter))
{
var tables = target.Query <dynamic>("SELECT * FROM sys.tables WHERE [type] = @0", 'U').ToList();
Assert.IsTrue(tables.Any());
Assert.IsNotNull(tables.FirstOrDefault()?.name);
Assert.IsTrue(tables.FirstOrDefault()?.object_id > 0);
var tableCount = target.ExecuteScalar <int>("SELECT COUNT(1) FROM sys.tables WHERE [type] = @0", 'U');
Assert.AreNotEqual(0, tableCount);
}
}
public void Join_LocalAttributeToRelatedAttribute_MatchesExpected()
{
var definitionProvider = new DataAnnotationsDefinitionProvider();
var actual = new EntityRelation(EntityRelationType.InnerJoin);
actual.Join <ChildRaisedRow>(row => row.ComplexEntityId, row => row.ComplexEntity.ComplexEntityId);
var childDefinition = definitionProvider.Resolve <ChildRaisedRow>();
var childReference = new EntityReference {
EntityType = typeof(ChildRaisedRow)
};
var childLocation = definitionProvider.GetEntityLocation(childReference);
var childAttributeLocation = new AttributeLocation(typeof(ChildRaisedRow).GetProperty("ComplexEntityId"), childReference);
var childComplexIdAttribute = childDefinition.Find(childAttributeLocation);
Assert.AreEqual(childLocation, childDefinition.Find(actual.SourceExpression).Entity);
Assert.AreEqual(childComplexIdAttribute, childDefinition.Find(actual.SourceExpression)); //// actual.SourceAttribute);
var complexDefinition = definitionProvider.Resolve <ComplexRaisedRow>();
var complexReference = new EntityReference {
EntityType = typeof(ComplexRaisedRow)
};
var complexLocation = definitionProvider.GetEntityLocation(complexReference);
var complexAttributeLocation = new AttributeLocation(typeof(ComplexRaisedRow).GetProperty("ComplexEntityId"), complexReference);
var complexIdAttribute = complexDefinition.Find(complexAttributeLocation);
Assert.AreEqual(complexLocation, complexDefinition.Find(actual.RelationExpression).Entity); //// actual.RelationLocation);
Assert.AreEqual(complexIdAttribute, complexDefinition.Find(actual.RelationExpression));
}
public void Find_RelatedAttributeAliasedEntity_MatchesExpected()
{
var entityReference = new EntityReference {
EntityType = typeof(ChildRaisedRow)
};
var definitionProvider = new DataAnnotationsDefinitionProvider();
var target = new EntityDefinition(definitionProvider, entityReference);
var relationReference = new EntityReference {
EntityType = typeof(SubRow), EntityAlias = "SubEntity"
};
var attributeLocation = definitionProvider.GetEntityLocation(relationReference);
var attributePath = new LinkedList <EntityLocation>();
attributePath.AddLast(attributeLocation);
var expected = new EntityAttributeDefinition(
attributePath,
relationReference.EntityType.GetProperty(nameof(SubRow.FakeSubEntityId), BindingFlags.Public | BindingFlags.Instance),
nameof(SubRow.FakeSubEntityId),
EntityAttributeTypes.RelatedAutoNumberKey,
1,
$"SubEntity.{nameof(SubRow.FakeSubEntityId)}");
var actual = target.Find(CreateExpression <ChildRaisedRow, int>(row => row.ComplexEntity.SubEntity.FakeSubEntityId));
Assert.AreEqual(expected, actual, string.Join(Environment.NewLine, expected.GetDifferences(actual)));
}
public void CreateDelegate_AttributeForDynamicObject_MatchesExpected()
{
var entityDefinition = new DataAnnotationsDefinitionProvider().Resolve <OverriddenColumnNameRow>();
var databaseContext = new Mock <IDatabaseContext>();
databaseContext.Setup(context => context.GetValueMapper(It.IsAny <Type>(), It.IsAny <Type>())).Returns((IValueMapper)null);
var expected = new OverriddenColumnNameRow
{
OverriddenColumnNameId = 12,
Description = "my desc",
EntryTime = DateTimeOffset.Now,
Name = "name",
RelatedRowId = 234,
RelatedRowName = "relatedName"
};
using (var dataReader = expected.MockDataReader(entityDefinition.DirectAttributes).Object)
{
dataReader.Read();
var dataRequest = new PocoDataRequest(dataReader, entityDefinition, databaseContext.Object);
var func = FlatPocoFactory.CreateDelegate <dynamic>(dataRequest).MappingDelegate as Func <IDataReader, dynamic>;
Assert.IsNotNull(func);
var actual = func(dataReader);
foreach (var definition in entityDefinition.DirectAttributes)
{
Assert.AreEqual(definition.GetValueDelegate.DynamicInvoke(expected), ((IDictionary <string, object>)actual)[definition.ReferenceName]);
}
}
}
public void UpdateSingle_AnonymousTypeInput_MappedToEntity()
{
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.Update(It.IsAny <UpdateSet <SubRow> >())).Verifiable();
using (var provider = repositoryProvider.Object)
{
var repository = new EntityRepository <SubEntity, SubRow>(provider, this.mapper);
repository.UpdateSingle(
4444,
new
{
UniqueOtherId = (short)65,
Description = "new desc"
},
entity => entity.UniqueOtherId,
entity => entity.Description);
}
repositoryProvider.Verify();
}
public void Join_ExplicitSourceAndRelationTypes_EntityRelationMatchesExpected()
{
var definitionProvider = new DataAnnotationsDefinitionProvider();
var actual = new EntityRelation(EntityRelationType.InnerJoin);
actual.Join <FakeRelatedRow, DependencyRow>(row => row.RelatedId, row => row.FakeDependencyEntityId);
var relatedDefinition = definitionProvider.Resolve <FakeRelatedRow>();
var leftDefinition = relatedDefinition;
var leftReference = new EntityReference {
EntityType = typeof(FakeRelatedRow)
};
var leftLocation = definitionProvider.GetEntityLocation(leftReference);
var leftAttributeLocation = new AttributeLocation(typeof(FakeRelatedRow).GetProperty(nameof(FakeRelatedRow.RelatedId)), leftReference);
var leftAttribute = leftDefinition.Find(leftAttributeLocation);
Assert.AreEqual(leftLocation, relatedDefinition.Find(actual.SourceExpression).Entity);
Assert.AreEqual(leftAttribute, relatedDefinition.Find(actual.SourceExpression));
var rightDefinition = definitionProvider.Resolve <DependencyRow>();
var rightReference = new EntityReference {
EntityType = typeof(DependencyRow)
};
var rightLocation = definitionProvider.GetEntityLocation(rightReference);
var rightAttributeLocation = new AttributeLocation(typeof(DependencyRow).GetProperty(nameof(DependencyRow.FakeDependencyEntityId)), rightReference);
var rightAttribute = rightDefinition.Find(rightAttributeLocation);
Assert.AreEqual(rightLocation, rightDefinition.Find(actual.RelationExpression).Entity);
Assert.AreEqual(rightAttribute, rightDefinition.Find(actual.RelationExpression));
}
public async Task UpdateSingleAsync_AnonymousTypeInput_MappedToEntity()
{
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.UpdateAsync(It.IsAny <UpdateSet <SubRow> >(), It.IsAny <CancellationToken>())).Verifiable();
await using (var provider = repositoryProvider.Object)
{
var repository = new EntityRepository <SubEntity, SubRow>(provider, this.mapper);
await repository.UpdateSingleAsync(
4444,
new
{
UniqueOtherId = (short)65,
Description = "new desc"
},
CancellationToken.None,
entity => entity.UniqueOtherId,
entity => entity.Description).ConfigureAwait(false);
}
repositoryProvider.Verify();
}
public void ExecuteNonQuery_SqlCommand_ExecutesNonQuery()
{
var providerName = "System.Data.SqlClient";
#if !NET472
if (DbProviderFactories.GetProviderInvariantNames().Any(s => string.Equals(s, providerName, StringComparison.Ordinal)) == false)
{
Trace.WriteLine($"Registering {providerName} factory");
DbProviderFactories.RegisterFactory(providerName, SqlClientFactory.Instance);
}
#endif
var connectionString = ConfigurationRoot.GetConnectionString("MasterDatabase");
var definitionProvider = new DataAnnotationsDefinitionProvider();
var statementCompiler = new TransactSqlAdapter(definitionProvider);
using (var target = new DatabaseContext(connectionString, providerName, statementCompiler))
{
target.OpenSharedConnection();
var sqlConnection = target.Connection as SqlConnection;
Assert.IsNotNull(sqlConnection);
using (var transaction = sqlConnection.BeginTransaction())
{
using (var command = new SqlCommand("SELECT TOP 1 * FROM sys.tables", sqlConnection, transaction))
{
command.ExecuteNonQuery();
}
transaction.Rollback();
}
}
}
public void Insert_NonIdentityKey_MatchesExpected()
{
var mockDatabaseFactory = new Mock <IDatabaseContextFactory>();
var mockDatabaseContext = new Mock <IDatabaseContext>();
mockDatabaseFactory.Setup(factory => factory.Create()).Returns(mockDatabaseContext.Object);
var repositoryAdapter = new Mock <IRepositoryAdapter>();
mockDatabaseContext.Setup(context => context.RepositoryAdapter).Returns(repositoryAdapter.Object);
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryAdapter.Setup(compiler => compiler.CreateInsertionStatement <DependentRow>()).Returns(string.Empty);
repositoryAdapter.Setup(adapter => adapter.DefinitionProvider).Returns(definitionProvider);
var databaseFactory = mockDatabaseFactory.Object;
using (var target = new DatabaseRepositoryProvider(databaseFactory))
{
var expected = new DependentRow
{
FakeDependentEntityId = 234,
DependentIntegerValue = 4583,
DependentTimeValue = DateTimeOffset.Now
};
var actual = target.Insert(expected);
Assert.AreSame(expected, actual);
}
}
public void CreateDelegate_RaisedPocoFactoryForRaisedComplexRowWithoutDependentEntity_DelegateSetsPocoAsExpected()
{
var expected = Generate.CreateFakeRaisedComplexRow(false);
var definitionProvider = new DataAnnotationsDefinitionProvider();
var entityDefinition = definitionProvider.Resolve <ComplexRaisedRow>();
var databaseContext = new Mock <IDatabaseContext>();
databaseContext.Setup(context => context.GetValueMapper(It.IsAny <Type>(), It.IsAny <Type>())).Returns((IValueMapper)null);
using (var target = new RaisedPocoFactory(definitionProvider))
{
var stopwatch = Stopwatch.StartNew();
ComplexRaisedRow actual;
using (var reader = expected.MockDataReader(entityDefinition.ReturnableAttributes).Object)
{
stopwatch.Start();
reader.Read();
actual = target.CreatePoco <ComplexRaisedRow>(new PocoDataRequest(reader, entityDefinition, databaseContext.Object));
Trace.TraceInformation($"{stopwatch.Elapsed} Invoke delegate #1");
}
stopwatch.Reset();
Assert.IsNotNull(actual);
Assert.AreEqual(expected.ComplexEntityId, actual.ComplexEntityId);
Assert.AreEqual(
expected.SubEntity,
actual.SubEntity,
string.Join(Environment.NewLine, expected.SubEntity.GetDifferences(actual.SubEntity)));
Assert.IsNull(expected.DependentEntity);
Assert.IsNull(actual.DependentEntity);
Assert.AreEqual(expected, actual, string.Join(Environment.NewLine, expected.GetDifferences(actual)));
stopwatch.Start();
using (var reader = expected.MockDataReader(entityDefinition.ReturnableAttributes).Object)
{
reader.Read();
target.CreatePoco <ComplexRaisedRow>(new PocoDataRequest(reader, entityDefinition, databaseContext.Object));
}
Trace.TraceInformation($"{stopwatch.Elapsed} Invoke delegate #2");
stopwatch.Reset();
stopwatch.Start();
using (var reader = expected.MockDataReader(entityDefinition.ReturnableAttributes).Object)
{
reader.Read();
target.CreatePoco <ComplexRaisedRow>(new PocoDataRequest(reader, entityDefinition, databaseContext.Object));
}
Trace.TraceInformation($"{stopwatch.Elapsed} Invoke delegate #3");
stopwatch.Reset();
}
}
public void ResolveEntityDefinitions_ForDomainAggregate_MatchesExpected()
{
var target = new DataAnnotationsDefinitionProvider();
var expected = GetAttributeDefinitions(typeof(DomainAggregateRow)).ToList();
var actual = target.ResolveDefinitions(typeof(DomainAggregateRow)).ToList();
CollectionAssert.AreEquivalent(expected, actual, string.Join(Environment.NewLine, actual.Except(expected)));
}
public void Database_ChangeDatabase_DatabaseChanged()
{
var definitionProvider = new DataAnnotationsDefinitionProvider();
var statementCompiler = new TransactSqlAdapter(definitionProvider);
using (var connection = new SqlConnection(ConfigurationRoot.GetConnectionString("MasterDatabase")))
using (var database = new DatabaseContext(connection, statementCompiler))
{
database.ChangeDatabase("master");
Assert.AreEqual("master", database.Connection.Database);
}
}
public void GetValueMapper_TransactSqlAdapterForDecimalMoney_ReturnsIValueMapper()
{
var definitionProvider = new DataAnnotationsDefinitionProvider();
var statementCompiler = new TransactSqlAdapter(definitionProvider);
using (var connection = new SqlConnection(ConfigurationRoot.GetConnectionString("MasterDatabase")))
using (var database = new DatabaseContext(connection, statementCompiler))
{
var actual = database.GetValueMapper(typeof(decimal), typeof(SqlMoney));
Assert.IsNotNull(actual);
}
}
public void GetEntityReference_DirectPropertyWithoutEntityAlias_MatchesExpected()
{
var target = new DataAnnotationsDefinitionProvider();
var expected = new EntityReference
{
ContainerType = null,
EntityType = typeof(ComplexRaisedRow),
EntityAlias = null
};
var actual = target.GetEntityReference(
typeof(ComplexRaisedRow).GetProperty(nameof(ComplexRaisedRow.FakeOtherEnumerationId)) ?? throw new InvalidOperationException());
Assert.AreEqual(expected, actual);
}
public void GetEntityReference_DirectAttributeWithoutEntityAlias_MatchesExpected()
{
var target = new DataAnnotationsDefinitionProvider();
Expression <Func <ComplexRaisedRow, object> > expression = row => row.FakeOtherEnumerationId;
var expected = new EntityReference
{
ContainerType = null,
EntityType = typeof(ComplexRaisedRow),
EntityAlias = null
};
var actual = target.GetEntityReference(expression);
Assert.AreEqual(expected, actual);
}
public void GetEntityReference_FlatRelatedPropertyInfoWithEntityAlias_MatchesExpected()
{
var target = new DataAnnotationsDefinitionProvider();
var expected = new EntityReference
{
ContainerType = null,
EntityType = typeof(MultiReferenceRow),
EntityAlias = "CreatedBy"
};
var actual = target.GetEntityReference(
typeof(ComplexFlatRow).GetProperty(nameof(ComplexFlatRow.CreatedByUniqueName)) ?? throw new InvalidOperationException());
Assert.AreEqual(expected, actual);
}
public void GetEntityReference_RelatedAttributeWithEntityAlias_MatchesExpected()
{
var target = new DataAnnotationsDefinitionProvider();
Expression <Func <ComplexRaisedRow, object> > expression = row => row.SubEntity.FakeSubSubEntityId;
var expected = new EntityReference
{
ContainerType = null,
EntityType = typeof(SubRow),
EntityAlias = nameof(ComplexRaisedRow.SubEntity)
};
var actual = target.GetEntityReference(expression);
Assert.AreEqual(expected, actual);
}
public void GetEntityReference_FlatRelatedAttributeWithEntityAlias_MatchesExpected()
{
var target = new DataAnnotationsDefinitionProvider();
Expression <Func <ComplexFlatRow, object> > expression = row => row.CreatedByUniqueName;
var expected = new EntityReference
{
ContainerType = null,
EntityType = typeof(MultiReferenceRow),
EntityAlias = "CreatedBy"
};
var actual = target.GetEntityReference(expression);
Assert.AreEqual(expected, actual);
}
public async Task OpenSharedConnectionAsync_SqlConnection_ConnectionOpened()
{
var definitionProvider = new DataAnnotationsDefinitionProvider();
var statementCompiler = new TransactSqlAdapter(definitionProvider);
await using (var connection = new SqlConnection(ConfigurationRoot.GetConnectionString("MasterDatabase")))
await using (var database = new DatabaseContext(connection, statementCompiler))
{
var cancellationToken = CancellationToken.None;
await database.OpenSharedConnectionAsync(cancellationToken);
await database.ChangeDatabaseAsync("master", cancellationToken);
Assert.AreEqual("master", database.Connection.Database);
}
}
public void CreateExistsStatement_DirectData_MatchesExpected()
{
var transactionSelection = Query
.From <DataRow>(
set => set.InnerJoin(row => row.FakeDataId, row => row.Related.FakeDataId)
.InnerJoin(row => row.Related.RelatedId, row => row.DependencyEntity.ComplexEntityId)
.InnerJoin(row => row.FakeDataId, row => row.OtherAlias.FakeDataId)
.InnerJoin(row => row.OtherAlias.RelatedId, row => row.RelatedDependency.ComplexEntityId)
.InnerJoin(row => row.FakeDataId, row => row.RelatedAlias.FakeDataId)
.LeftJoin <SubDataRow>(row => row.FakeDataId, row => row.FakeSubDataId))
.Where(
set => set.AreEqual(row => row.ValueColumn, 2)
.AreEqual(row => row.NullableColumn, "CouldHaveBeenNull")
.AreEqual(row => row.NullableValueColumn, null)
.Between(row => row.FakeDataId, 10, 20)
.GreaterThanOrEqualTo(row => row.NormalColumn, "Greater")
.LessThanOrEqualTo(row => row.AnotherColumn, "Less")
.Include(row => row.AnotherValueColumn, 5, 10, 15, 20))
.Sort(
set => set.OrderBy(row => row.Related.RelatedProperty)
.OrderByDescending(row => row.OtherAlias.RelatedProperty)
.OrderBy(row => row.NormalColumn));
const string Expected = @"SELECT EXISTS(SELECT
1
FROM ""dbo"".""FakeData""
INNER JOIN ""someschema"".""Related"" ON ""dbo"".""FakeData"".""FakeRowId"" = ""someschema"".""Related"".""FakeDataId""
INNER JOIN ""dbo"".""DependencyEntity"" ON ""someschema"".""Related"".""RelatedId"" = ""dbo"".""DependencyEntity"".""ComplexEntityId""
INNER JOIN ""someschema"".""Related"" AS ""OtherAlias"" ON ""dbo"".""FakeData"".""FakeRowId"" = ""OtherAlias"".""FakeDataId""
INNER JOIN ""dbo"".""DependencyEntity"" AS ""RelatedDependency"" ON ""OtherAlias"".""RelatedId"" = ""RelatedDependency"".""ComplexEntityId""
INNER JOIN ""someschema"".""Related"" AS ""RelatedAlias"" ON ""dbo"".""FakeData"".""FakeRowId"" = ""RelatedAlias"".""FakeDataId""
LEFT JOIN ""dbo"".""SubData"" ON ""dbo"".""FakeData"".""FakeRowId"" = ""dbo"".""SubData"".""FakeSubDataId""
WHERE ""dbo"".""FakeData"".""ValueColumn"" = @0 AND
""dbo"".""FakeData"".""NullableColumn"" LIKE @1 AND
""dbo"".""FakeData"".""NullableValueColumn"" IS NULL AND
""dbo"".""FakeData"".""FakeRowId"" BETWEEN @2 AND @3 AND
""dbo"".""FakeData"".""NormalColumn"" >= @4 AND
""dbo"".""FakeData"".""AnotherColumn"" <= @5 AND
""dbo"".""FakeData"".""AnotherValueColumn"" IN (@6, @7, @8, @9)
ORDER BY ""someschema"".""Related"".""RelatedProperty"", ""OtherAlias"".""RelatedProperty"" DESC, ""dbo"".""FakeData"".""NormalColumn"")";
var definitionProvider = new DataAnnotationsDefinitionProvider();
var target = new PostgreSqlAdapter(definitionProvider);
var actual = target.CreateExistsStatement(transactionSelection);
Assert.AreEqual(Expected, actual);
}
public void BeginTransaction_ExplicitIsolationLevel_IsolationLevelMatchesExpected()
{
var definitionProvider = new DataAnnotationsDefinitionProvider();
var statementCompiler = new TransactSqlAdapter(definitionProvider);
using (var connection = new SqlConnection(ConfigurationRoot.GetConnectionString("MasterDatabase")))
using (var database = new DatabaseContext(connection, statementCompiler))
{
database.OpenSharedConnection();
using (var transaction = database.BeginTransaction(IsolationLevel.RepeatableRead))
{
Assert.IsFalse(transaction.IsDisposed);
Assert.AreEqual(IsolationLevel.RepeatableRead, transaction.IsolationLevel);
}
}
}
public void DeleteEntities_ItemsBySelection_ReturnsMultipleRowsDeleted()
{
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.Delete(It.IsAny <IEntitySet>())).Returns(5);
int actual;
using (var provider = repositoryProvider.Object)
{
var repository = new EntityRepository <SubSubEntity, SubSubRow>(provider, this.mapper);
actual = repository.DeleteEntities(set => set.Where(filterSet => filterSet.AreEqual(entity => entity.UniqueName, "bar")));
}
Assert.AreEqual(5, actual);
}
public void Delete_ItemById_ReturnsSingleRowDeleted()
{
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.Delete(It.IsAny <IEntitySet>())).Returns(1);
int actual;
using (var provider = repositoryProvider.Object)
{
var repository = new EntityRepository <ComplexEntity, ComplexRaisedRow>(provider, this.mapper);
actual = repository.Delete(14);
}
Assert.AreEqual(1, actual);
}
public async Task DeleteAsync_ItemById_ReturnsSingleRowDeleted()
{
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.DeleteAsync(It.IsAny <IEntitySet>(), It.IsAny <CancellationToken>())).ReturnsAsync(1);
int actual;
using (var provider = repositoryProvider.Object)
{
var repository = new EntityRepository <ComplexEntity, ComplexRaisedRow>(provider, this.mapper);
actual = await repository.DeleteAsync(14, CancellationToken.None);
}
Assert.AreEqual(1, actual);
}
public void AssociateTransaction_SqlCommand_CommandTransactionIsSameAsExpected()
{
var definitionProvider = new DataAnnotationsDefinitionProvider();
var statementCompiler = new TransactSqlAdapter(definitionProvider);
using (var connection = new SqlConnection(ConfigurationRoot.GetConnectionString("MasterDatabase")))
using (var database = new DatabaseContext(connection, statementCompiler))
{
database.OpenSharedConnection();
var command = new SqlCommand("SELECT * FROM sys.tables WHERE [type] = @0");
using (var transaction = database.BeginTransaction(IsolationLevel.RepeatableRead))
{
database.AssociateTransaction(command);
Assert.IsNotNull(command.Transaction);
}
}
}
public async Task BeginTransactionAsync_ExplicitIsolationLevel_IsolationLevelMatchesExpected()
{
var definitionProvider = new DataAnnotationsDefinitionProvider();
var statementCompiler = new TransactSqlAdapter(definitionProvider);
await using (var connection = new SqlConnection(ConfigurationRoot.GetConnectionString("MasterDatabase")))
await using (var database = new DatabaseContext(connection, statementCompiler))
{
var cancellationToken = CancellationToken.None;
await database.OpenSharedConnectionAsync(cancellationToken);
await using (var transaction = await database.BeginTransactionAsync(IsolationLevel.RepeatableRead, CancellationToken.None))
{
Assert.IsFalse(transaction.IsDisposed);
Assert.AreEqual(IsolationLevel.RepeatableRead, transaction.IsolationLevel);
}
}
}
public void Save_NewFakeComplexEntity_MatchesExpected()
{
var subSubEntity = new SubSubEntity("SubSubUniqueName", 6445);
var subEntity = new SubEntity("SubUniqueName", 234, subSubEntity, 67893);
var createdBy = new CreatedBy("CreateUniqueName", 1122);
var modifiedBy = new ModifiedBy("ModifiedBy", 454);
var expected = new ComplexEntity("UniqueName", subEntity, FakeEnumeration.FirstFake, createdBy)
{
ModifiedBy = modifiedBy,
ModifiedTime = DateTimeOffset.Now.AddHours(1)
};
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.FirstOrDefault(It.IsAny <EntitySelection <ComplexRaisedRow> >()))
.Returns(default(ComplexRaisedRow));
repositoryProvider.Setup(provider => provider.Insert(It.IsAny <ComplexRaisedRow>()))
.Callback((ComplexRaisedRow row) => row.ComplexEntityId = 43)
.Returns((ComplexRaisedRow row) => row);
using (var provider = repositoryProvider.Object)
{
var target = new EntityRepository <ComplexEntity, ComplexRaisedRow>(provider, this.mapper);
var actual = target.Save(expected);
Assert.IsNotNull(actual.SubEntity);
Assert.IsNotNull(actual.SubEntity.SubSubEntity);
Assert.IsNotNull(actual.CreatedBy);
Assert.IsNotNull(actual.ModifiedBy);
Assert.AreEqual(6445, actual.SubSubEntity.FakeSubSubEntityId);
Assert.AreSame(expected.SubEntity.SubSubEntity, actual.SubEntity.SubSubEntity);
Assert.AreEqual(67893, actual.SubEntity.FakeSubEntityId);
Assert.AreEqual(expected.SubEntity, actual.SubEntity);
Assert.AreEqual(1122, actual.CreatedBy.FakeMultiReferenceEntityId);
Assert.AreEqual(expected.CreatedBy, actual.CreatedBy);
Assert.AreEqual(454, actual.ModifiedBy.FakeMultiReferenceEntityId);
Assert.AreEqual(expected.ModifiedBy, actual.ModifiedBy);
Assert.AreEqual(43, actual.ComplexEntityId);
Assert.AreEqual(expected, actual, string.Join(Environment.NewLine, expected.GetDifferences(actual)));
}
}
public void CreateDelegate_FlatPocoFactoryForComplexRow_IsNotNull()
{
var fakeComplexRow = Generate.CreateFakeComplexRow();
var entityDefinition = new DataAnnotationsDefinitionProvider().Resolve <ComplexFlatRow>();
var databaseContext = new Mock <IDatabaseContext>();
databaseContext.Setup(context => context.GetValueMapper(It.IsAny <Type>(), It.IsAny <Type>())).Returns((IValueMapper)null);
PocoDelegateInfo actual;
using (var reader = fakeComplexRow.MockDataReader(entityDefinition.ReturnableAttributes).Object)
{
reader.Read();
var pocoDataRequest = new PocoDataRequest(reader, entityDefinition, databaseContext.Object);
actual = FlatPocoFactory.CreateDelegate <ComplexFlatRow>(pocoDataRequest);
}
Assert.IsNotNull(actual);
}
public void Update_UpdateModelSet_MappedToUpdateEntitySet()
{
var repositoryProvider = new Mock <IRepositoryProvider>();
var definitionProvider = new DataAnnotationsDefinitionProvider();
repositoryProvider.Setup(provider => provider.EntityDefinitionProvider).Returns(definitionProvider);
repositoryProvider.Setup(provider => provider.Update(It.IsAny <UpdateSet <SubSubRow> >())).Returns(1);
int actual;
using (var provider = repositoryProvider.Object)
{
var repository = new EntityRepository <SubSubEntity, SubSubRow>(provider, this.mapper);
actual = repository.Update(
new UpdateSet <SubSubEntity>().Set(entity => entity.UniqueName, "newName")
.Where(filterSet => filterSet.AreEqual(entity => entity.UniqueName, "bar")));
}
Assert.AreEqual(1, actual);
}