public void Should_throw_exception_when_saving_non_selected_language()
{
var resourceProvider = new Mock <IDefaultLocalizationResourceProvider>();
var preferencesService = new Mock <IPreferencesService>();
var locManager = new Mock <ILocalizationManager>();
SetupMockFailCase(locManager, resourceProvider, preferencesService);
var languageService = new LanguagesService(new Cache(), locManager.Object, resourceProvider.Object, preferencesService.Object, new Mock <IStorageProvider>().Object, new Mock <IMapper>().Object);
try
{
languageService.Save(new Language()
{
Abrv = "de",
IsSelected = false,
Name = "German"
});
}
catch (Exception ex)
{
ex.GetType().Should().Be(typeof(InvalidOperationException));
CurrentLocale.CultureName.Should().Be("en");
}
}
public async Task UpdateAsyncCorrectlyUpdatesInformation()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
await context.Languages.AddRangeAsync(this.SeedData());
await context.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Language>(context);
var service = new LanguagesService(repository);
var model = new EditViewModel
{
Name = "NewName",
IsDeleted = true,
};
var result = await service.UpdateAsync(1, model);
Assert.NotEqual(-1, result);
var dbRecord = await context.Languages.FindAsync(1);
Assert.NotEqual("First", dbRecord.Name);
Assert.NotNull(dbRecord.DeletedOn);
Assert.True(dbRecord.IsDeleted);
}
public void Should_not_set_selected_language()
{
var resourceProvider = new Mock <IDefaultLocalizationResourceProvider>();
var preferencesService = new Mock <IPreferencesService>();
var locManager = new Mock <ILocalizationManager>();
SetupMockSuccessCase(locManager, resourceProvider, preferencesService);
var languageService = new LanguagesService(new Cache(), locManager.Object, resourceProvider.Object, preferencesService.Object, new Mock <IStorageProvider>().Object, new Mock <IMapper>().Object);
var languages = new List <ILanguage>
{
new Language()
{
Abrv = "en",
IsSelected = true
},
new Language()
{
Abrv = "de",
IsSelected = false
}
};
var result = languageService.SetSelected(languages, new Language()
{
Abrv = "en",
IsSelected = true
});
result.Should().Be(false);
CurrentLocale.CultureName.Should().Be("en");
}
public void Should_return_selected_language_by_supported_name_block()
{
var resourceProvider = new Mock <IDefaultLocalizationResourceProvider>();
var preferencesService = new Mock <IPreferencesService>();
var locManager = new Mock <ILocalizationManager>();
SetupMockSuccessCase(locManager, resourceProvider, preferencesService);
locManager.Setup(p => p.GetResource(It.IsAny <string>(), It.IsAny <string>())).Returns((string l, string r) =>
{
if (r.Contains("SupportedNameBlock"))
{
if (l.Equals("jp"))
{
return("IsKatakana");
}
return(string.Empty);
}
return("Roboto");
});
resourceProvider.Setup(p => p.GetAvailableLocales()).Returns(() =>
{
return(new List <string>()
{
"en", "de", "jp"
});
});
var languageService = new LanguagesService(new Cache(), locManager.Object, resourceProvider.Object, preferencesService.Object, new Mock <IStorageProvider>().Object, new Mock <IMapper>().Object);
var l = languageService.GetLanguageBySupportedNameBlock("test");
l.Abrv.Should().Be("en");
}
public virtual async Task <ActionResult> ImportResources(int langId, HttpPostedFileBase xmlFile)
{
var language = await LanguagesService.FindByIdAsync(langId);
if (language == null)
{
return(RedirectToAction("PageNotFound", "Error"));
}
try
{
string xmlContent = new StreamReader(xmlFile.InputStream).ReadToEnd();
await _localizationService.ImportResourcesFromXmlAsync(language.Id, xmlContent);
SuccessNotification(_localizationService.GetResource("StringResourcesImportedSuccessfully"));
}
catch (Exception e)
{
var errorCode = ErrorLog.GetDefault(System.Web.HttpContext.Current).Log(new Error(e, System.Web.HttpContext.Current));
ErrorNotification(string.Format(_localizationService.GetResource("ErrorOnOperation"), e.Message,
errorCode));
}
return(RedirectToAction("Index", new { langId = langId }));
}
protected void Application_Start()
{
LanguagesService.RegisterLanguages();
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
public void AddSingleBook_CheckIfDataCountIsCorrect()
{
Assert.AreEqual(1, BooksService.GetAllWithData().Count(), "Books");
Assert.AreEqual(3, LanguagesService.GetAll().Count(), "Langs");
Assert.AreEqual(9, WordsService.GetWordsWithData().Count(), "Words");
Assert.AreEqual(3, MasterWordsService.GetAll().Count(), "MasterWords");
Assert.AreEqual(1, AccountService.GetAll().Count(), "Accounts");
}
public void CanAdd_Word_ToDatabase()
{
var beforeWords = WordsService.GetAll().Count();
WordsService.Add(new Word()
{
MasterWord = new MasterWord(), Text = "Something", Language = LanguagesService.GetAll().First()
});
Assert.AreEqual(beforeWords + 1, WordsService.GetWordsWithData().Count());
}
public async Task DeleteFailsWhenIdNotInDatabase()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
var repository = new EfDeletableEntityRepository <Language>(context);
var service = new LanguagesService(repository);
var result = await service.DeleteAsync(100);
Assert.False(result);
}
public void Should_apply_selected_language()
{
var resourceProvider = new Mock <IDefaultLocalizationResourceProvider>();
var preferencesService = new Mock <IPreferencesService>();
var locManager = new Mock <ILocalizationManager>();
SetupMockSuccessCase(locManager, resourceProvider, preferencesService);
var languageService = new LanguagesService(new Cache(), locManager.Object, resourceProvider.Object, preferencesService.Object, new Mock <IStorageProvider>().Object, new Mock <IMapper>().Object);
languageService.ApplySelected().Should().Be(true);
CurrentLocale.CultureName.Should().Be("en");
}
public void Should_return_selected_language()
{
var resourceProvider = new Mock <IDefaultLocalizationResourceProvider>();
var preferencesService = new Mock <IPreferencesService>();
var locManager = new Mock <ILocalizationManager>();
SetupMockSuccessCase(locManager, resourceProvider, preferencesService);
var languageService = new LanguagesService(new Cache(), locManager.Object, resourceProvider.Object, preferencesService.Object, new Mock <IStorageProvider>().Object, new Mock <IMapper>().Object);
var result = languageService.GetSelected();
result.Abrv.Should().Be("en");
}
public void Should_not_return_any_language()
{
var resourceProvider = new Mock <IDefaultLocalizationResourceProvider>();
var preferencesService = new Mock <IPreferencesService>();
var locManager = new Mock <ILocalizationManager>();
SetupMockFailCase(locManager, resourceProvider, preferencesService);
var languageService = new LanguagesService(locManager.Object, resourceProvider.Object, preferencesService.Object, new Mock <IStorageProvider>().Object, new Mock <IMapper>().Object);
var result = languageService.GetSelected();
result.Should().BeNull();
}
public virtual async Task <ActionResult> SetLanguageAsDefault(int id)
{
try
{
await LanguagesService.SetAsDefaultAsync(id);
return(Content("OK"));
}
catch (Exception e)
{
var errorCode = ErrorLog.GetDefault(System.Web.HttpContext.Current).Log(new Error(e, System.Web.HttpContext.Current));
return(Content(string.Format(_localizationService.GetResource("ErrorOnOperation"), e.Message, errorCode)));
}
}
public void Should_not_contain_selected_language()
{
var resourceProvider = new Mock <IDefaultLocalizationResourceProvider>();
var preferencesService = new Mock <IPreferencesService>();
var locManager = new Mock <ILocalizationManager>();
SetupMockFailCase(locManager, resourceProvider, preferencesService);
var languageService = new LanguagesService(locManager.Object, resourceProvider.Object, preferencesService.Object, new Mock <IStorageProvider>().Object, new Mock <IMapper>().Object);
var result = languageService.Get();
result.Count().Should().Be(2);
result.Count(p => p.IsSelected).Should().Be(0);
}
public virtual async Task <ActionResult> Editor(int?id)
{
if (id != null)
{
var record = await LanguagesService.FindByIdAsync(id.Value);
if (record != null)
{
return(View(await _languageModelFactory.PrepareLanguageModelAsync(record)));
}
}
return(View(await _languageModelFactory.PrepareLanguageModelAsync(null)));
}
public async Task GetAllReturnsCorrectNumberOfRecords()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
await context.Languages.AddRangeAsync(this.SeedData());
await context.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Language>(context);
var service = new LanguagesService(repository);
var result = service.GetAll <EditViewModel>();
Assert.Equal(2, result.Count());
}
public virtual async Task <ActionResult> Delete(int[] keys)
{
try
{
foreach (var key in keys)
{
await LanguagesService.DeleteAsync(key);
}
return(Content("OK"));
}
catch (Exception e)
{
var errorCode = ErrorLog.GetDefault(System.Web.HttpContext.Current).Log(new Error(e, System.Web.HttpContext.Current));
return(Content(string.Format(_localizationService.GetResource("ErrorOnOperation"), e.Message, errorCode)));
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (db != null)
{
db.Dispose();
db = null;
}
if (Service != null)
{
Service.Dispose();
Service = null;
}
}
base.Dispose(disposing);
}
public async Task UpdateAsyncFailsWhenIdNotInDb()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
var repository = new EfDeletableEntityRepository <Language>(context);
var service = new LanguagesService(repository);
var model = new EditViewModel
{
Name = "NewName",
IsDeleted = true,
};
var result = await service.UpdateAsync(100, model);
Assert.Equal(-1, result);
}
public bool IsFirstInit(LanguagesService service = default)
{
try
{
if (CookieExits("Language"))
{
return(false);
}
else
{
SaveCookie("Language", Service.Language);
SaveCookie("Country", Service.Region);
SaveCookie("SelectedTheme", "Dark");
return(true);
}
}
catch (Exception ex) { throw new Exception($"Error al crear los cookies. \n{ex.Message}"); }
}
public virtual async Task <ActionResult> Editor(LanguageModel model, bool?saveAndContinue)
{
if (!ModelState.IsValid)
{
model.CurrenciesList = await CurrencyService.GetAsSelectListAsync();
return(View(model));
}
var record = _languageModelFactory.PrepareTblLanguages(model);
var recordId = model.Id;
try
{
if (model.Id == null)
{
//Add new record
recordId = await LanguagesService.AddAsync(record);
}
else
{
//Edit record
await LanguagesService.UpdateAsync(record);
}
}
catch (Exception e)
{
var errorCode = ErrorLog.GetDefault(System.Web.HttpContext.Current).Log(new Error(e, System.Web.HttpContext.Current));
ModelState.AddModelError("", string.Format(_localizationService.GetResource("ErrorOnOperation"), e.Message, errorCode));
model.CurrenciesList = await CurrencyService.GetAsSelectListAsync();
return(View(model));
}
if (saveAndContinue != null && saveAndContinue.Value)
{
return(RedirectToAction("Editor", "ManageLanguages", new { id = recordId }));
}
return(Content(@"<script language='javascript' type='text/javascript'>
window.close();
window.opener.refreshLanguagesGrid();
</script>"));
}
public void Should_save_selected_language()
{
var resourceProvider = new Mock <IDefaultLocalizationResourceProvider>();
var preferencesService = new Mock <IPreferencesService>();
var locManager = new Mock <ILocalizationManager>();
SetupMockSuccessCase(locManager, resourceProvider, preferencesService);
var languageService = new LanguagesService(new Cache(), locManager.Object, resourceProvider.Object, preferencesService.Object, new Mock <IStorageProvider>().Object, new Mock <IMapper>().Object);
var result = languageService.Save(new Language()
{
Abrv = "de",
IsSelected = true,
Name = "German"
});
result.Should().Be(true);
CurrentLocale.CultureName.Should().Be("de");
}
protected virtual async Task <string> RemoveLanguageFromUrl(string url)
{
var isoList = await LanguagesService.GetAllLanguagesIsoListAsync();
foreach (var lang in isoList)
{
if (url.StartsWith($"/{lang}/", StringComparison.InvariantCultureIgnoreCase))
{
url = url.Remove(0, $"/{lang}/".Length);
}
}
if (!url.StartsWith("/"))
{
url = "/" + url;
}
return(url);
}
public async Task CreateSuccessfullyAddsNewLanguage()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
var repository = new EfDeletableEntityRepository <Language>(context);
var service = new LanguagesService(repository);
var model = new CreateViewModel
{
Name = "New Language",
IsDeleted = true,
};
int id = await service.CreateAsync(model);
Assert.NotEqual(-1, id);
Assert.Equal(1, context.Languages.IgnoreQueryFilters().Count());
}
public async Task GetDetailsReturnsCorrectInformation()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
await context.Languages.AddRangeAsync(this.SeedData());
await context.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Language>(context);
var service = new LanguagesService(repository);
var result = service.GetDetails <EditViewModel>(1);
Assert.NotNull(result);
Assert.Equal(1, result.Id);
Assert.Equal("First", result.Name);
Assert.False(result.IsDeleted);
}
public virtual async Task <ActionResult> ExportResources(int langId)
{
var language = await LanguagesService.FindByIdAsync(langId);
if (language == null)
{
return(RedirectToAction("PageNotFound", "Error"));
}
var xmlString = await _localizationService.ExportResourcesToXmlAsync(language);
var contentType = "text/xml";
var bytes = Encoding.UTF8.GetBytes(xmlString);
var result = new FileContentResult(bytes, contentType);
result.FileDownloadName = $"DigiCommerce.StringResources.{language.IsoCode}.xml";
return(result);
}
public virtual async Task <ActionResult> Index(int langId)
{
var language = await LanguagesService.FindByIdAsync(langId);
if (language == null)
{
return(RedirectToAction("PageNotFound", "Error"));
}
ViewBag.LangId = langId;
ViewBag.LangName = language.LanguageName;
ViewBag.LanguagesDropDown = LanguagesService.GetAsEnumerable().Select(p => new
{
text = p.LanguageName,
value = p.Id.ToString()
}).ToList();
return(View());
}
public virtual ActionResult GridDataSource(DataManager dm)
{
var query = LanguagesService.GetAsQueryable();
var dataSource = query.Select(p => new
{
p.Id,
p.DisplayOrder,
p.LanguageName,
p.IsoCode,
p.IsDefault,
p.IsRtl,
p.Published,
});
var result = dataSource.ApplyDataManager(dm, out var count).ToList();
return(Json(dm.RequiresCounts ? new { result = result, count = count } : (object)result,
JsonRequestBehavior.AllowGet));
}
public async Task DeleteMarksRecordAsDeleted()
{
AutoMapperInitializer.InitializeMapper();
var context = InMemoryDbContextInitializer.InitializeContext();
await context.Languages.AddAsync(new Language { Id = 1, Name = "Language", IsDeleted = false });
await context.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Language>(context);
var service = new LanguagesService(repository);
var result = await service.DeleteAsync(1);
var dbRecord = await context.Languages.FindAsync(1);
Assert.True(result);
Assert.True(dbRecord.IsDeleted);
Assert.NotNull(dbRecord.DeletedOn);
Assert.Equal(1, context.Languages.IgnoreQueryFilters().Count());
}
public async Task Setup()
{
// Arrange
var datnekContext = await DatnekContextProvider.GetDatabaseContext();
languagesService = new LanguagesService(datnekContext);
var user = await GetUser(datnekContext);
language = new Language()
{
slug = "123",
title = "en",
speak = 2,
read = 3,
understand = 2,
userId = user.id,
user = new User(),
createdAt = DateTime.Now,
updatedAt = DateTime.Now
};
}
