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_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_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_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_GetCountryTimeZoneInfo()
{
using (var entityManager = new CountriesEntityManager()) {
var countryTimeZoneInfos = entityManager.CountryTimeZoneInfos
.ToList();
Assert.IsNotNull(countryTimeZoneInfos);
Assert.AreNotEqual(notExpected: 0, actual: countryTimeZoneInfos.Count);
var countryInfosOrderedByCountryISO2 = countryTimeZoneInfos
.GroupBy(x => x.CountryISO2)
.OrderByDescending(x => x.Count())
.SelectMany(x => x)
.ToList();
foreach (var countryTimeZoneInfo in countryInfosOrderedByCountryISO2)
{
Debug.WriteLine(countryTimeZoneInfo.ToString());
}
foreach (var countryTimeZoneInfo in countryTimeZoneInfos)
{
Debug.WriteLine(countryTimeZoneInfo.ToString());
Assert.IsNotNull(countryTimeZoneInfo.ToString());
}
Debug.WriteLine(CountryTimeZoneInfo.CSVString);
foreach (var countryTimeZoneInfo in countryTimeZoneInfos)
{
Debug.WriteLine(countryTimeZoneInfo.ToCSVString());
Assert.IsNotNull(countryTimeZoneInfo.ToCSVString());
}
}
}
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_GetCountryInfo()
{
using (var entityManager = new CountriesEntityManager()) {
var countryInfos = entityManager.CountryInfos
.ToList();
Assert.IsNotNull(countryInfos);
Assert.AreNotEqual(notExpected: 0, actual: countryInfos.Count);
var countryInfosOrderedByContinentCount = countryInfos
.GroupBy(x => x.ContinentName)
.OrderByDescending(x => x.Count())
.SelectMany(x => x)
.ToList();
var countryInfosOrderedByCallingCodeNumberCount = countryInfos
.GroupBy(x => x.CallingCodeNumber)
.OrderByDescending(x => x.Count())
.SelectMany(x => x)
.ToList();
var countryInfosOrderedByName = countryInfos
.OrderBy(x => x.Name)
.ToList();
foreach (var countryInfo in countryInfosOrderedByCallingCodeNumberCount)
{
Debug.WriteLine(countryInfo.ToString());
}
foreach (var countryInfo in countryInfosOrderedByName)
{
Debug.WriteLine(countryInfo.Name);
}
foreach (var countryInfo in countryInfos)
{
Debug.WriteLine(countryInfo.ToString());
Assert.IsNotNull(countryInfo.ToString());
}
Debug.WriteLine(Country.CSVString);
foreach (var countryInfo in countryInfos)
{
Debug.WriteLine(countryInfo.ToCSVString());
Assert.IsNotNull(countryInfo.ToCSVString());
}
}
}
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_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_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);
}
}
}
private void DeleteDatabaseObjects()
{
using (var entityManager = new CountriesEntityManager()) {
try {
var sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[Continent] WHERE ([Abbreviation] = '{continentAbbreviationCreate}');");
entityManager.ExecuteScalarSql(sqlCommand);
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[Continent] WHERE ([Abbreviation] = '{continentAbbreviationUpdate}');");
entityManager.ExecuteScalarSql(sqlCommand);
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[Continent] WHERE ([Abbreviation] = '{continentAbbreviationDelete}');");
entityManager.ExecuteScalarSql(sqlCommand);
}
catch (Exception e) {
Log.Error($"[ThreadID: {Thread.CurrentThread.ManagedThreadId}] {ObjectExtensions.CurrentMethodName()} {e.VerboseExceptionString()}");
}
}
}
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);
}
}
private void DeleteDatabaseObjects()
{
using (var entityManager = new CountriesEntityManager()) {
try {
var sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[CallingCode] WHERE ([CallingCodeNumber] = {callingCodeNumberCreate});");
entityManager.ExecuteScalarSql(sqlCommand);
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[CallingCode] WHERE ([CallingCodeNumber] = {callingCodeNumberUpdate});");
entityManager.ExecuteScalarSql(sqlCommand);
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[CallingCode] WHERE ([CallingCodeNumber] = {callingCodeNumberUpdate2});");
entityManager.ExecuteScalarSql(sqlCommand);
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[CallingCode] WHERE ([CallingCodeNumber] = {callingCodeNumberDelete});");
entityManager.ExecuteScalarSql(sqlCommand);
}
catch (Exception e) {
Log.Error($"[ThreadID: {Thread.CurrentThread.ManagedThreadId}] {ObjectExtensions.CurrentMethodName()} {e.VerboseExceptionString()}");
}
}
}
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_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_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_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_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;
}
}
private void DeleteDatabaseObjects()
{
using (var entityManager = new CountriesEntityManager()) {
try {
var sqlCommand = new SqlCommand($"SELECT [Id] FROM [Countries].[dbo].[Currency] WHERE ([Code] = '{currencyCodeCreate}');");
int currencyCodeCreateId = Convert.ToInt32(entityManager.ExecuteScalarSql(sqlCommand));
if (currencyCodeCreateId > 0)
{
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[CountryCurrency] WHERE ([CurrencyId] = '{currencyCodeCreateId}');");
entityManager.ExecuteScalarSql(sqlCommand);
}
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[Currency] WHERE ([Code] = '{currencyCodeCreate}');");
entityManager.ExecuteScalarSql(sqlCommand);
sqlCommand = new SqlCommand($"SELECT [Id] FROM [Countries].[dbo].[Currency] WHERE ([Code] = '{currencyCodeUpdate}');");
int currencyCodeUpdateId = Convert.ToInt32(entityManager.ExecuteScalarSql(sqlCommand));
if (currencyCodeUpdateId > 0)
{
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[CountryCurrency] WHERE ([CurrencyId] = '{currencyCodeUpdateId}');");
entityManager.ExecuteScalarSql(sqlCommand);
}
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[Currency] WHERE ([Code] = '{currencyCodeUpdate}');");
entityManager.ExecuteScalarSql(sqlCommand);
sqlCommand = new SqlCommand($"SELECT [Id] FROM [Countries].[dbo].[Currency] WHERE ([Code] = '{currencyCodeDelete}');");
int currencyCodeDeleteId = Convert.ToInt32(entityManager.ExecuteScalarSql(sqlCommand));
if (currencyCodeDeleteId > 0)
{
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[CountryCurrency] WHERE ([CurrencyId] = '{currencyCodeDeleteId}');");
entityManager.ExecuteScalarSql(sqlCommand);
}
sqlCommand = new SqlCommand($"DELETE [Countries].[dbo].[Currency] WHERE ([Code] = '{currencyCodeDelete}');");
entityManager.ExecuteScalarSql(sqlCommand);
}
catch (Exception e) {
Log.Error($"[ThreadID: {Thread.CurrentThread.ManagedThreadId}] {ObjectExtensions.CurrentMethodName()} {e.VerboseExceptionString()}");
}
}
}
public void Test_GetCountryCurrencyInfos()
{
using (var entityManager = new CountriesEntityManager()) {
var countryCurrencyInfos = entityManager.CountryCurrencyInfos
.ToList();
Assert.IsNotNull(countryCurrencyInfos);
Assert.AreNotEqual(notExpected: 0, actual: countryCurrencyInfos.Count);
var countryCurrencyInfosOrderedByCountryCount = countryCurrencyInfos
.GroupBy(x => x.CountryId)
.OrderByDescending(x => x.Count())
.SelectMany(x => x)
.ToList();
foreach (var countryCurrencyInfo in countryCurrencyInfos)
{
Debug.WriteLine(countryCurrencyInfo.ToString());
Assert.IsNotNull(countryCurrencyInfo.ToString());
}
Debug.WriteLine(CountryCurrencyInfo.CSVString);
foreach (var countryCurrencyInfo in countryCurrencyInfos)
{
Debug.WriteLine(countryCurrencyInfo.ToCSVString());
Assert.IsNotNull(countryCurrencyInfo.ToCSVString());
}
// Check for known countries that have multiple currencies to validate the View is
// being keyed properly.
Assert.IsTrue(countryCurrencyInfos.Any(x => string.Equals(x.ToCSVString(), "\"30249\",\"ZW\",\"ZWE\",\"716\",\"Zimbabwe\",\"40028\",\"Botswana pula\",\"BWP\"")));
Assert.IsTrue(countryCurrencyInfos.Any(x => string.Equals(x.ToCSVString(), "\"30249\",\"ZW\",\"ZWE\",\"716\",\"Zimbabwe\",\"40054\",\"Euro\",\"EUR\"")));
Assert.IsTrue(countryCurrencyInfos.Any(x => string.Equals(x.ToCSVString(), "\"30249\",\"ZW\",\"ZWE\",\"716\",\"Zimbabwe\",\"40057\",\"Pound Sterling\",\"GBP\"")));
Assert.IsTrue(countryCurrencyInfos.Any(x => string.Equals(x.ToCSVString(), "\"30249\",\"ZW\",\"ZWE\",\"716\",\"Zimbabwe\",\"40158\",\"United States dollar\",\"USD\"")));
Assert.IsTrue(countryCurrencyInfos.Any(x => string.Equals(x.ToCSVString(), "\"30249\",\"ZW\",\"ZWE\",\"716\",\"Zimbabwe\",\"40188\",\"South African rand\",\"ZAR\"")));
}
}
public void Test_TimeZone_Schema()
{
using (var entityManager = new CountriesEntityManager()) {
var continents = entityManager.Set <Countries.DomainModel.TimeZone>().Take(1).ToList();
}
}
public void Test_CallingCode_Schema()
{
using (var entityManager = new CountriesEntityManager()) {
var callingCodes = entityManager.Set <CallingCode>().Take(1).ToList();
}
}
public void Test_Continent_Schema()
{
using (var entityManager = new CountriesEntityManager()) {
var continents = entityManager.Set <Continent>().Take(1).ToList();
}
}
