public void DeleteSelection_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.DeleteSelection(new EntitySet <SubSubEntity>().Where(set => set.AreEqual(entity => entity.UniqueName, "bar")));
}
Assert.AreEqual(5, actual);
}
public void ExecuteForResults_ListOfFields_DoesNotThrowException()
{
var internalId = new Field
{
Name = "INS_Internal ID",
Description = "Unique ID used internally"
};
var firstName = new Field
{
Name = "INS_First Name",
Description = "The person's first name"
};
var lastName = new Field
{
Name = "INS_Last Name",
Description = "The person's last name"
};
var yearlyWage = new Field
{
Name = "INS_Yearly Wage",
Description = "The base wage paid year over year."
};
var hireDate = new Field
{
Name = "INS_Hire Date",
Description = "The date and time of hire for the person"
};
var bonusTarget = new Field
{
Name = "INS_Bonus Target",
Description = "The target bonus for the person"
};
var contactNumbers = new Field
{
Name = "INS_Contact Numbers",
Description = "A list of contact numbers for the person in order of preference"
};
var fields = new List <Field>
{
internalId,
firstName,
lastName,
yearlyWage,
hireDate,
bonusTarget,
contactNumbers
};
var providerFactory = new PostgreSqlProviderFactory(new DataAnnotationsDefinitionProvider());
using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDbPg")))
{
var fieldRepository = new EntityRepository <Field, FieldRow>(provider, this.mapper);
// Delete the existing rows.
fieldRepository.DeleteSelection(Query.From <FieldRow>().Where(set => set.AreEqual(row => row.Name, "INS_%")));
var transaction = provider.BeginTransaction();
// Set up the structured command provider.
var structuredCommandProvider = new JsonCommandFactory();
var fieldInsertCommand =
new JsonInsert <FieldRow>(provider.DatabaseContext).Returning(
row => row.FieldId,
row => row.Description);
var actual = fieldInsertCommand.ExecuteForResults(
fields.Select(
field => new FieldRow
{
Name = field.Name,
Description = field.Description
}));
foreach (var fieldRow in actual)
{
Assert.AreNotEqual(0, fieldRow.FieldId);
}
transaction.Commit();
}
}
public void ExecuteForResults_MultipleGenericSubmissions_MatchesExpected()
{
var internalId = new Field
{
Name = "MERGE_Existing_Internal ID",
Description = "Unique ID used internally"
};
var firstName = new Field
{
Name = "MERGE_Existing_First Name",
Description = "The person's first name"
};
var lastName = new Field
{
Name = "MERGE_Existing_Last Name",
Description = "The person's last name"
};
var yearlyWage = new Field
{
Name = "MERGE_Existing_Yearly Wage",
Description = "The base wage paid year over year."
};
var hireDate = new Field
{
Name = "MERGE_NonExisting_Hire Date",
Description = "The date and time of hire for the person"
};
var bonusTarget = new Field
{
Name = "MERGE_NonExisting_Bonus Target",
Description = "The target bonus for the person"
};
var contactNumbers = new Field
{
Name = "MERGE_NonExisting_Contact Numbers",
Description = "A list of contact numbers for the person in order of preference"
};
var providerFactory = new PostgreSqlProviderFactory(new DataAnnotationsDefinitionProvider());
GenericSubmission baselineSubmission;
DomainIdentity domainIdentity2;
using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDbPg")))
{
// Set up the domain identity, not part of our validity testing.
var identityRepository = new EntityRepository <DomainIdentity, DomainIdentityRow>(provider, this.mapper);
var domainIdentity = identityRepository.FirstOrDefault(
Query.Select <DomainIdentity>()
.Where(set => set.AreEqual(identity => identity.UniqueIdentifier, Environment.UserName)))
?? identityRepository.Save(
new DomainIdentity(Environment.UserName)
{
FirstName = "King",
MiddleName = "T.",
LastName = "Animal"
});
var domainIdentifier2 = $"{Environment.UserName}2";
domainIdentity2 = identityRepository.FirstOrDefault(
Query.Select <DomainIdentity>()
.Where(set => set.AreEqual(identity => identity.UniqueIdentifier, domainIdentifier2)))
?? identityRepository.Save(
new DomainIdentity(domainIdentifier2)
{
FirstName = "Foo",
MiddleName = "J.",
LastName = "Bar"
});
// We will add to this submission later.
baselineSubmission = new GenericSubmission("My MERGE Submission", domainIdentity);
baselineSubmission.SetValue(internalId, 9234);
baselineSubmission.SetValue(firstName, "Dan");
baselineSubmission.SetValue(lastName, "The Man");
baselineSubmission.SetValue(yearlyWage, 72150.35m); // gonna get updated so lets check that this value got scrapped
baselineSubmission.Submit();
this.MergeSubmission(baselineSubmission, provider);
}
Assert.IsTrue(baselineSubmission.GenericSubmissionId.HasValue);
// Reusing the key lets us test whether updates are in fact working as expected.
var expected = new GenericSubmission(
"My Final MERGE Submission",
domainIdentity2,
baselineSubmission.GenericSubmissionId.GetValueOrDefault());
expected.SetValue(yearlyWage, 75100.35m);
expected.SetValue(hireDate, new DateTimeOffset(DateTimeOffset.Now.Date));
expected.SetValue(bonusTarget, 1.59834578934);
expected.SetValue(
contactNumbers,
new List <string>
{
"423-222-2252",
"615-982-0012",
"+1-555-252-5521"
});
expected.Submit();
GenericSubmission actual;
// Using a new provider clears any provider-level caches
using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDbPg")))
{
var fieldValueRepository = new EntityRepository <FieldValue, FieldValueRow>(provider, this.mapper);
// Get rid of all the previous fields.
fieldValueRepository.DeleteSelection(
Query.From <FieldValueRow>()
.Where(
set => set.Include(
row => row.FieldValueId,
baselineSubmission.SubmissionValues.Select(value => value.FieldValueId).ToArray())));
this.MergeSubmission(expected, provider);
var submissionRepository = new EntityRepository <GenericSubmission, GenericSubmissionRow>(provider, this.mapper);
actual = submissionRepository.FirstOrDefault(expected.GenericSubmissionId);
var genericSubmissionValueRepository = new EntityRepository <FieldValue, GenericSubmissionValueRow>(provider, this.mapper);
var values = genericSubmissionValueRepository.SelectEntities(
Query.Select <GenericSubmissionValueRow>()
.From(
set => set.InnerJoin(row => row.GenericSubmissionValueId, row => row.FieldValue.FieldValueId)
.InnerJoin(row => row.FieldValue.FieldId, row => row.FieldValue.Field.FieldId)
.InnerJoin(
row => row.FieldValue.LastModifiedByDomainIdentifierId,
row => row.FieldValue.LastModifiedBy.DomainIdentityId))
.Where(set => set.AreEqual(row => row.GenericSubmissionId, expected.GenericSubmissionId.GetValueOrDefault())))
.ToDictionary(value => value.FieldValueId.GetValueOrDefault(), value => value);
actual.Load(values.Values);
var valueElementRows = provider.SelectEntities(
Query.Select <FieldValueElementPgFlatRow>()
.From(
set => set.LeftJoin <DateElementRow>(row => row.FieldValueElementId, row => row.DateElementId)
.LeftJoin <FloatElementRow>(row => row.FieldValueElementId, row => row.FloatElementId)
.LeftJoin <IntegerElementRow>(row => row.FieldValueElementId, row => row.IntegerElementId)
.LeftJoin <MoneyElementRow>(row => row.FieldValueElementId, row => row.MoneyElementId)
.LeftJoin <TextElementRow>(row => row.FieldValueElementId, row => row.TextElementId))
.Where(set => set.Include(row => row.FieldValueId, values.Keys.ToArray())))
.ToList();
foreach (var key in values.Keys)
{
values[key]
.Load(
from e in valueElementRows
where e.FieldValueId == key
orderby e.Order
select new FieldValueElement(
e.DateElement ?? e.FloatElement ?? e.IntegerElement ?? e.MoneyElement ?? e.TextElement as object,
e.FieldValueElementId.GetValueOrDefault()));
}
}
var expectedElements = expected.SubmissionValues.SelectMany(value => value.Elements)
.OrderBy(element => element.FieldValueElementId)
.ToList();
var actualElements = actual.SubmissionValues.SelectMany(value => value.Elements).OrderBy(element => element.FieldValueElementId).ToList();
var firstExpectedElement = expectedElements.Skip(1).First();
var firstActualElement = actualElements.Skip(1).FirstOrDefault();
Assert.AreEqual(
firstExpectedElement,
firstActualElement,
string.Join(Environment.NewLine, firstExpectedElement.GetDifferences(firstActualElement)));
CollectionAssert.AreEqual(expectedElements, actualElements);
Assert.AreEqual(expected, actual, string.Join(Environment.NewLine, expected.GetDifferences(actual)));
CollectionAssert.AreEqual(
expected.SubmissionValues.OrderBy(x => x.FieldValueId).ToList(),
actual.SubmissionValues.OrderBy(x => x.FieldValueId).ToList());
}
public void Execute_TableValueInsertForFields_DoesNotThrowException()
{
var internalId = new Field
{
Name = "INS_Internal ID",
Description = "Unique ID used internally"
};
var firstName = new Field
{
Name = "INS_First Name",
Description = "The person's first name"
};
var lastName = new Field
{
Name = "INS_Last Name",
Description = "The person's last name"
};
var yearlyWage = new Field
{
Name = "INS_Yearly Wage",
Description = "The base wage paid year over year."
};
var hireDate = new Field
{
Name = "INS_Hire Date",
Description = "The date and time of hire for the person"
};
var bonusTarget = new Field
{
Name = "INS_Bonus Target",
Description = "The target bonus for the person"
};
var contactNumbers = new Field
{
Name = "INS_Contact Numbers",
Description = "A list of contact numbers for the person in order of preference"
};
var fields = new List <Field>
{
internalId,
firstName,
lastName,
yearlyWage,
hireDate,
bonusTarget,
contactNumbers
};
var providerFactory = new SqlClientProviderFactory(new DataAnnotationsDefinitionProvider());
using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDb")))
{
var transaction = provider.BeginTransaction();
var fieldRepository = new EntityRepository <Field, FieldRow>(provider, this.mapper);
var fieldValueRepository = new EntityRepository <FieldValue, FieldValueRow>(provider, this.mapper);
// Delete the existing rows.
var fieldSelection = Query.Select <FieldRow>().Where(set => set.AreEqual(row => row.Name, "INS_%"));
var existingFields = fieldRepository.SelectEntities(fieldSelection);
fieldValueRepository.DeleteSelection(
Query.Select <FieldValueRow>()
.Where(set => set.Include(row => row.FieldId, existingFields.Select(field => field.FieldId).ToArray())));
fieldRepository.DeleteSelection(fieldSelection);
var fieldInsertCommand = new TableValuedInsert <FieldRow>(provider.DatabaseContext);
fieldInsertCommand.Execute(
fields.Select(
field => new FieldTableTypeRow
{
Name = field.Name,
Description = field.Description
}));
transaction.Commit();
}
}
