public void Test_Country_Delete()
{
var country = new Country()
{
DetachedState = DetachedState.Added,
Capital = countryCapitalDelete,
ISO2 = countryISO2Delete,
ISO3 = countryISO3Delete,
ISOName = countryISONameDelete,
ISONumeric = countryISONumericDelete,
Name = countryNameDelete,
OfficialName = countryOfficialNameDelete,
OfficialNameLocal = countryOfficialNameLocalDelete
};
using (var entityManager = new CountriesEntityManager()) {
var continent = entityManager.Set <Continent>()
.Where(x => x.Name == continentName)
.Single();
country.Continent = continent;
var currency = entityManager.Set <Currency>()
.Where(x => x.Code == currencyCode)
.Single();
country.Currencies.Add(currency);
var validationResults = Get_Validation_Results(country);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
entityManager.AddEntity <Country>(country);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var countryFromDb = entityManager.Set <Country>()
.Where(x => (x.Id == country.Id))
// need to include related entities
.Include(x => x.Currencies)
.Include(x => x.Continent)
.SingleOrDefault();
Assert.IsNotNull(countryFromDb);
entityManager.RemoveEntity <Country>(countryFromDb);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
countryFromDb = entityManager.Set <Country>()
.Where(x => (x.Id == country.Id))
.SingleOrDefault();
Assert.IsNull(countryFromDb);
}
}
public void Test_Country_Create()
{
var country = new Country()
{
DetachedState = DetachedState.Added,
Capital = countryCapitalCreate,
ISO2 = countryISO2Create,
ISO3 = countryISO3Create,
ISOName = countryISONameCreate,
ISONumeric = countryISONumericCreate,
Name = countryNameCreate,
OfficialName = countryOfficialNameCreate,
OfficialNameLocal = countryOfficialNameLocalCreate
};
using (var entityManager = new CountriesEntityManager()) {
var continent = entityManager.Set <Continent>()
.Where(x => x.Name == continentName)
.Single();
country.Continent = continent;
var currency = entityManager.Set <Currency>()
.Where(x => x.Code == currencyCode)
.Single();
country.Currencies.Add(currency);
var validationResults = Get_Validation_Results(country);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
entityManager.AddEntity <Country>(country);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var countryFromDb = entityManager.Set <Country>()
.Where(x => (x.Id == country.Id))
.Include(x => x.Currencies)
.Include(x => x.Continent)
.SingleOrDefault();
Assert.IsNotNull(countryFromDb);
Assert.AreEqual(expected: country.ToCSVString(), actual: countryFromDb.ToCSVString());
// all entity properties must be virtual for this to work
var proxy = countryFromDb as IEntityWithChangeTracker;
Assert.IsNotNull(proxy);
}
}
public void Test_CallingCode_Update()
{
var callingCode = new CallingCode()
{
DetachedState = DetachedState.Added,
CallingCodeNumber = callingCodeNumberUpdate
};
var validationResults = Get_Validation_Results(callingCode);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
using (var entityManager = new CountriesEntityManager()) {
entityManager.AddEntity <CallingCode>(callingCode);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
callingCode.CallingCodeNumber = callingCodeNumberUpdate2;
using (var entityManager = new CountriesEntityManager()) {
entityManager.Attach <CallingCode>(callingCode);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var callingCodeFromDb = entityManager.Set <CallingCode>()
.Where(x => (x.Id == callingCode.Id))
.SingleOrDefault();
Assert.IsNotNull(callingCodeFromDb);
Assert.AreEqual(expected: callingCodeNumberUpdate2, actual: callingCodeFromDb.CallingCodeNumber);
}
}
public void Test_CallingCode_Create()
{
var callingCode = new CallingCode()
{
DetachedState = DetachedState.Added,
CallingCodeNumber = callingCodeNumberCreate
};
var validationResults = Get_Validation_Results(callingCode);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
using (var entityManager = new CountriesEntityManager()) {
entityManager.AddEntity <CallingCode>(callingCode);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var dallingCodeFromDb = entityManager.Set <CallingCode>()
.Where(x => (x.Id == callingCode.Id))
.SingleOrDefault();
Assert.IsNotNull(dallingCodeFromDb);
Assert.AreEqual(expected: callingCode.ToCSVString(), actual: dallingCodeFromDb.ToCSVString());
// all entity properties must be virtual for this to work
var proxy = dallingCodeFromDb as IEntityWithChangeTracker;
Assert.IsNotNull(proxy);
}
}
public void Test_Continent_Create()
{
var continent = new Continent()
{
DetachedState = DetachedState.Added,
Abbreviation = continentAbbreviationCreate,
Name = continentNameCreate
};
var validationResults = Get_Validation_Results(continent);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
using (var entityManager = new CountriesEntityManager()) {
entityManager.AddEntity <Continent>(continent);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var continentFromDb = entityManager.Set <Continent>()
.Where(x => (x.Id == continent.Id))
.SingleOrDefault();
Assert.IsNotNull(continentFromDb);
Assert.AreEqual(expected: continent.ToCSVString(), actual: continentFromDb.ToCSVString());
// all entity properties must be virtual for this to work
var proxy = continentFromDb as IEntityWithChangeTracker;
Assert.IsNotNull(proxy);
}
}
public void Test_TimeZone_Create()
{
var timeZone = new Countries.DomainModel.TimeZone()
{
DetachedState = DetachedState.Added,
TimeZoneAcronym = timeZoneAbbreviationCreate,
TimeZoneName = timeZoneNameCreate,
UTCOffset = timeZoneUTCOffsetCreate
};
var validationResults = Get_Validation_Results(timeZone);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
using (var entityManager = new CountriesEntityManager()) {
entityManager.AddEntity <Countries.DomainModel.TimeZone>(timeZone);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var timeZoneFromDb = entityManager.Set <Countries.DomainModel.TimeZone>()
.Where(x => (x.Id == timeZone.Id))
.SingleOrDefault();
Assert.IsNotNull(timeZoneFromDb);
Assert.AreEqual(expected: timeZone.ToCSVString(), actual: timeZoneFromDb.ToCSVString());
// all entity properties must be virtual for this to work
var proxy = timeZoneFromDb as IEntityWithChangeTracker;
Assert.IsNotNull(proxy);
}
}
public void Test_TimeZone_ChangeTracker()
{
using (var entityManager = new CountriesEntityManager()) {
var timeZone = entityManager.Set <Countries.DomainModel.TimeZone>().Create();
timeZone = entityManager.Set <Countries.DomainModel.TimeZone>().Add(timeZone);
var changeTrackerEntry = entityManager.Entry <Countries.DomainModel.TimeZone>(timeZone);
var changeTrackerEntries = entityManager.ChangeTracker.Entries().ToList();
Assert.IsNotNull(changeTrackerEntry);
Assert.AreEqual(expected: 1, actual: changeTrackerEntries.Count);
var timeZoneHashCode = timeZone.GetHashCode();
var changeTrackerEntryEntityHashCode = changeTrackerEntries.Single().Entity.GetHashCode();
Assert.AreEqual(timeZoneHashCode, changeTrackerEntryEntityHashCode);
timeZone = null;
}
}
public void Test_Continent_ChangeTracker()
{
using (var entityManager = new CountriesEntityManager()) {
var continent = entityManager.Set <Continent>().Create();
continent = entityManager.Set <Continent>().Add(continent);
var changeTrackerEntry = entityManager.Entry <Continent>(continent);
var changeTrackerEntries = entityManager.ChangeTracker.Entries().ToList();
Assert.IsNotNull(changeTrackerEntry);
Assert.AreEqual(expected: 1, actual: changeTrackerEntries.Count);
var continentHashCode = continent.GetHashCode();
var changeTrackerEntryEntityHashCode = changeTrackerEntries.Single().Entity.GetHashCode();
Assert.AreEqual(continentHashCode, changeTrackerEntryEntityHashCode);
continent = null;
}
}
public void Test_TimeZone_Delete()
{
var timeZone = new Countries.DomainModel.TimeZone()
{
DetachedState = DetachedState.Added,
TimeZoneAcronym = timeZoneAbbreviationDelete,
TimeZoneName = timeZoneNameDelete,
UTCOffset = timeZoneUTCOffsetDelete
};
var validationResults = Get_Validation_Results(timeZone);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
using (var entityManager = new CountriesEntityManager()) {
entityManager.AddEntity <Countries.DomainModel.TimeZone>(timeZone);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var timeZoneFromDb = entityManager.Set <Countries.DomainModel.TimeZone>()
.Where(x => (x.Id == timeZone.Id))
.SingleOrDefault();
Assert.IsNotNull(timeZoneFromDb);
}
var timeZoneToDelete = new Countries.DomainModel.TimeZone()
{
DetachedState = DetachedState.Deleted,
Id = timeZone.Id,
RowVersion = timeZone.RowVersion
};
using (var entityManager = new CountriesEntityManager()) {
entityManager.RemoveEntity <Countries.DomainModel.TimeZone>(timeZoneToDelete);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var timeZoneFromDb = entityManager.Set <Countries.DomainModel.TimeZone>()
.Where(x => (x.Id == timeZone.Id))
.SingleOrDefault();
Assert.IsNull(timeZoneFromDb);
}
}
public void Test_Currency_Delete()
{
var currency = new Currency()
{
DetachedState = DetachedState.Added,
Code = currencyCodeDelete,
DecimalDigits = 2,
Name = currencyNameDelete
};
var validationResults = Get_Validation_Results(currency);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
using (var entityManager = new CountriesEntityManager()) {
entityManager.AddEntity <Currency>(currency);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var currencyFromDb = entityManager.Set <Currency>()
.Where(x => (x.Id == currency.Id))
.SingleOrDefault();
Assert.IsNotNull(currencyFromDb);
}
var currencyToDelete = new Currency()
{
DetachedState = DetachedState.Deleted,
Id = currency.Id,
RowVersion = currency.RowVersion
};
using (var entityManager = new CountriesEntityManager()) {
entityManager.RemoveEntity <Currency>(currencyToDelete);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var currencyFromDb = entityManager.Set <Currency>()
.Where(x => (x.Id == currency.Id))
.SingleOrDefault();
Assert.IsNull(currencyFromDb);
}
}
public void Test_CallingCode_GetCallingCodes()
{
using (var entityManager = new CountriesEntityManager()) {
var callingCodes = entityManager.Set <CallingCode>().ToList();
Assert.IsNotNull(callingCodes);
Assert.AreNotEqual(notExpected: 0, actual: callingCodes.Count);
foreach (var callingCode in callingCodes)
{
// all entity properties must be virtual for this to work
var proxy = callingCode as IEntityWithChangeTracker;
Assert.IsNotNull(proxy);
}
}
}
public void Test_Continent_Delete()
{
var continent = new Continent()
{
DetachedState = DetachedState.Added,
Abbreviation = continentAbbreviationDelete,
Name = continentNameDelete
};
var validationResults = Get_Validation_Results(continent);
Assert.AreEqual(expected: 0, actual: validationResults.Count);
using (var entityManager = new CountriesEntityManager()) {
entityManager.AddEntity <Continent>(continent);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var continentFromDb = entityManager.Set <Continent>()
.Where(x => (x.Id == continent.Id))
.SingleOrDefault();
Assert.IsNotNull(continentFromDb);
}
var continentToDelete = new Continent()
{
DetachedState = DetachedState.Deleted, Id = continent.Id
};
using (var entityManager = new CountriesEntityManager()) {
entityManager.RemoveEntity <Continent>(continentToDelete);
int updateCount = entityManager.SaveChanges();
Assert.AreNotEqual(notExpected: 0, actual: updateCount);
}
using (var entityManager = new CountriesEntityManager()) {
var continentFromDb = entityManager.Set <Continent>()
.Where(x => (x.Id == continent.Id))
.SingleOrDefault();
Assert.IsNull(continentFromDb);
}
}
public void Test_Country_GetCountrys()
{
using (var entityManager = new CountriesEntityManager()) {
var countries = entityManager.Set <Country>()
.Include(x => x.CallingCode)
.Include(x => x.Continent)
.Include(x => x.Currencies)
.ToList();
Assert.IsNotNull(countries);
Assert.AreNotEqual(notExpected: 0, actual: countries.Count);
foreach (var country in countries)
{
// all entity properties must be virtual for this to work
var proxy = country as IEntityWithChangeTracker;
Assert.IsNotNull(proxy);
try {
Assert.IsTrue(country.StringPropertiesAreTrim());
}
catch (Exception e) {
Debug.WriteLine($"Country: {country.ToCSVString()}");
throw;
}
try {
Assert.IsFalse(country.ToCSVString().Contains("ʻ"));
}
catch (Exception e) {
Debug.WriteLine($"Country: {country.ToCSVString()}");
throw;
}
try {
Assert.IsFalse(country.ToCSVString().Contains("’"));
}
catch (Exception e) {
Debug.WriteLine($"Country: {country.ToCSVString()}");
throw;
}
}
}
}
public void Test_Continent_GetContinents()
{
using (var entityManager = new CountriesEntityManager()) {
var continents = entityManager.Set <Continent>()
.Include(x => x.Countries)
.ToList();
Assert.IsNotNull(continents);
Assert.AreNotEqual(notExpected: 0, actual: continents.Count);
foreach (var continent in continents)
{
// all entity properties must be virtual for this to work
var proxy = continent as IEntityWithChangeTracker;
Assert.IsNotNull(proxy);
Assert.IsTrue(continent.StringPropertiesAreTrim());
}
}
}
public void Test_TimeZone_GetTimeZones()
{
using (var entityManager = new CountriesEntityManager()) {
var timeZones = entityManager.Set <Countries.DomainModel.TimeZone>()
.Include(x => x.Countries)
.ToList();
Assert.IsNotNull(timeZones);
Assert.AreNotEqual(notExpected: 0, actual: timeZones.Count);
foreach (var timeZone in timeZones)
{
// all entity properties must be virtual for this to work
var proxy = timeZone as IEntityWithChangeTracker;
Assert.IsNotNull(proxy);
Assert.IsTrue(timeZone.StringPropertiesAreTrim());
}
}
}
public void Test_CallingCode_Schema()
{
using (var entityManager = new CountriesEntityManager()) {
var callingCodes = entityManager.Set <CallingCode>().Take(1).ToList();
}
}
public void Test_TimeZone_Schema()
{
using (var entityManager = new CountriesEntityManager()) {
var continents = entityManager.Set <Countries.DomainModel.TimeZone>().Take(1).ToList();
}
}
public void Test_Continent_Schema()
{
using (var entityManager = new CountriesEntityManager()) {
var continents = entityManager.Set <Continent>().Take(1).ToList();
}
}
