public void RemovingAllWords_FromMaster_WillDeleteMasterAsWell(bool oneByOne) { var master = MasterWordsService.GetAll().First(); var book = master.Books.First(); var before = MasterWordsService.GetAll().Count(); var beforeInBook = book.Words.Count(); if (oneByOne) { foreach (var w in master.Words.ToArray()) { WordsService.Remove(w); } } else { WordsService.Remove(master.Words); } var secondMaster = MasterWordsService.GetAll().First(); Assert.AreNotEqual(secondMaster, master); Assert.AreEqual(before - 1, MasterWordsService.GetAll().Count(), "Master count missmatch"); Assert.AreEqual(beforeInBook - 1, book.Words.Count(), "Word in book count missmatch"); }
public ActionResult Index(int gridHeight = 3, int gridWidth = 3) { var model = new GridModel(gridHeight, gridWidth) { WordLengths = new List <int> { 3 } }; if (Request.HttpMethod == "POST") { model.WordLengths = new List <int> { Convert.ToInt32(Request["wordLength1"]) }; for (var i = 0; i < gridHeight; i++) { var currentRow = model.Rows[i]; for (var n = 0; n < gridWidth; n++) { currentRow[n] = new CellModel(model, i, n) { Value = Request.Form[$"col{i}_{n}"].ToLower() }; } } var service = new WordsService(); var combos = service.GetAllCandidateWords(model, 0); model.ValidWords.Add(combos.Children.ToList()); } return(View(model)); }
public void RemovingLink_BetweenTwoWords_FirstArgWillKeepTheMasterWithAllTranslations() { // Arrange var masterA = new MasterWord(); var wordInFirstArg = new Word(masterA, "Hi", new Language("English")); var translation = new Word(masterA, "Hola", new Language("Spanish")); new Word(masterA, "some word", new Language("some lang")); MasterWordsService.Add(masterA); // Act WordsService.RemoveTranslation(wordInFirstArg, translation); // Assert var newMaster = MasterWordsService.Get(masterA.ID); var newWord = WordsService.Get(wordInFirstArg.ID); var newTranslation = WordsService.Get(translation.ID); Assert.AreEqual(2, newMaster.Words.Count, "Master should have two words left"); Assert.AreEqual(newMaster, newWord.MasterWord, "Word in first argument should keep the master word"); Assert.AreEqual(1, newTranslation.MasterWord.Words.Count, "Translation master should only have 1 translation"); Assert.AreNotEqual(newTranslation.MasterWord, newWord.MasterWord, "Word in second argument should get new master created"); }
public void CreateDictionary() { // Arrange var fileReader = Substitute.For <IFileReader>(); fileReader.ReadFile("fileName.txt").Returns(new Dictionary <string, int>() { { "блок", 50 }, { "блоха", 20 }, { "блокада", 10 }, { "катерина", 30 }, { "катер", 20 }, }); var wordsService = new WordsService(GlobalTransactionScopeTestSetUp.Context, fileReader); // Act wordsService.CreateDictionary("fileName.txt").GetAwaiter().GetResult(); // Assert var addedWords = GlobalTransactionScopeTestSetUp.Context.Words.ToList(); Assert.That(addedWords.Count == 5); Assert.That(addedWords.Any(w => w.Count == 50 && w.Value == "блок")); Assert.That(addedWords.Any(w => w.Count == 20 && w.Value == "блоха")); Assert.That(addedWords.Any(w => w.Count == 10 && w.Value == "блокада")); Assert.That(addedWords.Any(w => w.Count == 30 && w.Value == "катерина")); Assert.That(addedWords.Any(w => w.Count == 20 && w.Value == "катер")); }
public async Task GetAllWordsAsync_ReturnsEmptySetIfNone() { var service = new WordsService(_context); var actual = await service.GetAllWordsAsync <Adverb>("en"); Assert.Empty(actual); }
public Words_ViewModel(WordsModel model, WordType?wtype, int tt, IUnitOfWork uw) { _uow = uw; Contract.Requires(model != null); WordsInfo = model; word = new WordsService(_uow); option = new OptionService(_uow); language = new LanguageServise(_uow); listitem = new ListItems(); chatmodel = new MSChartVM(); //chatmodel.BarChart(); charttest = chatmodel.BarSeriesCollection; TT = tt; AllLanguages = GetAllLanguages(); allWordTypes = listitem.GetWordType(); app = option.GetAll(); wt = wtype; RefreshProducts(); ConfigureValidationRules(); Validator.ResultChanged += OnValidationResultChanged; }
public async Task GetRandomWordAsync_ReturnsNullIfNone() { var service = new WordsService(_context); var actual = await service.GetRandomWordAsync <Adverb>("en"); Assert.Null(actual); }
public async Task GetWordByIdAsync_ReturnsNullIfNotFound() { var service = new WordsService(_context); var actual = await service.GetWordByIdAsync <Adjective>(12); Assert.Null(actual); }
public async Task UpdateWordsAsync_ReturnsPartialSetWhenSomeExist() { const int expectedCount = 3; var expected = (await FeedTestData(_context, expectedCount)).OfType <Adjective>().ToList(); expected.ForEach(word => { word.Value = "Changed"; word.IsDeleted = !word.IsDeleted; word.IsVulgar = !word.IsVulgar; word.LanguageCode = "pl"; }); var nonExistent = new List <Adjective> { GenerateWord <Adjective>(false, false), GenerateWord <Adjective>(false, false), GenerateWord <Adjective>(false, false) }; var service = new WordsService(_context); var actual = await service.UpdateWordsAsync(expected.Concat(nonExistent).ToList()); Assert.Equal(expectedCount, actual.Count); actual.Select(w => w.Id).Should().Equal(expected.Select(w => w.Id)); actual.Select(w => w.Value).Should().Equal(expected.Select(w => w.Value)); actual.Select(w => w.IsDeleted).Should().Equal(expected.Select(w => w.IsDeleted)); actual.Select(w => w.IsVulgar).Should().Equal(expected.Select(w => w.IsVulgar)); actual.Select(w => w.LanguageCode).Should().Equal(expected.Select(w => w.LanguageCode)); }
public void RemovingLink_BetweenTwoWords_WillCreateNewMasterWordForIt(bool cleanCache) { // Arrange var masterA = new MasterWord(); var wordA = new Word(masterA, "Hi", new Language("English")); var wordB = new Word(masterA, "Hola", new Language("Spanish")); MasterWordsService.Add(masterA); if (cleanCache) { RefreshServicesAndClearCache(); wordA = WordsService.GetAll().First(w => w.ID == wordA.ID); wordB = WordsService.GetAll().First(w => w.ID == wordB.ID); } // Act WordsService.RemoveTranslation(wordA, wordB); // Assert var newA = WordsService.Get(wordA.ID); var newB = WordsService.Get(wordB.ID); masterA = MasterWordsService.Get(masterA.ID); Assert.AreNotEqual(newA.MasterWord, newB.MasterWord, "Master words should differ. New Ref"); Assert.AreNotEqual(wordA.MasterWord, wordB.MasterWord, "Master words should differ. Old Ref"); Assert.AreEqual(1, masterA.Words.Count(), "MasterWord word count should be 1"); }
public void GettingWords_ContainsALanguageAndListOfTranslation() { var word = WordsService.GetWordsWithData().First(); Assert.IsNotNull(word.Language); Assert.IsNotNull(word.Translations); Assert.AreEqual(2, word.Translations.Count()); }
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 async Task GetRandomWordAsync_WithVulgarFilter_ReturnsNullIfNone() { await FeedTestData(_context, 1); var service = new WordsService(_context); var actual = await service.GetRandomWordAsync <Adverb>("en", useVulgar : true); Assert.Null(actual); }
public async Task UpdateWordAsync_ReturnsNullWhenDoesNotExist() { var expected = GenerateWord <Noun>(false, false); var service = new WordsService(_context); var actual = await service.UpdateWordAsync(expected); Assert.Null(actual); }
public async Task GetRandomWordAsync_WithVulgarFilter_ReturnsNullWhenNoneInLanguage() { await FeedTestData(_context, 3); var service = new WordsService(_context); var actual = await service.GetRandomWordAsync <Adjective>("pl", useVulgar : true); Assert.Null(actual); }
public MainWindow() { InitializeComponent(); _wordsService = new WordsService(); _yandexServices = new YandexServices(); _textBox.PreviewMouseDoubleClick += TextBox_PreviewMouseDoubleClick; }
public async Task GetRandomWordAsync_ReturnsWordIfAny() { await FeedTestData(_context, 3); var service = new WordsService(_context); var actual = await service.GetRandomWordAsync <Noun>("en"); Assert.NotNull(actual); Assert.IsType <Noun>(actual); }
public void RemovingDefinition_FromWord_WillUpdateDB() { var word = WordsService.GetWordsWithData().First(); word.Definition = null; WordsService.Update(word); var newWord = WordsService.GetWordsWithData().First(); Assert.AreEqual(null, newWord.Definition, "Definition should be empty"); }
public async Task CreateWordAsync_AddsNewWord() { var expected = GenerateWord <Adverb>(false, false); var service = new WordsService(_context); var actual = await service.CreateWordAsync(expected); Assert.Equal(expected.Id, actual); Assert.Equal(1, _context.Set <Adverb>().Count()); }
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 GetRandomWordAsync_WithVulgarFilter_ReturnsWordIfAny() { await FeedTestData(_context, 3); var service = new WordsService(_context); var actual = await service.GetRandomWordAsync <Noun>("en", useVulgar : true); Assert.NotNull(actual); Assert.IsType <Noun>(actual); Assert.True(actual.IsVulgar); }
public void RemovingWord_WithExplanationsAndDefinitions_UdpatesDB() { var before = WordsService.GetAll().Count(); var word = WordsService.GetWordsWithData().First(); WordsService.Remove(word); var after = WordsService.GetAll().Count(); Assert.AreEqual(before - 1, after, "Count missmatch"); }
public async Task DeleteWordAsync_ReturnsIdWhenExists() { const int count = 3; var expected = (await FeedTestData(_context, count)).OfType <Adverb>().First(); var service = new WordsService(_context); var actual = await service.DeleteWordAsync(expected); Assert.Equal(expected.Id, actual); Assert.Equal(count - 1, _context.Set <Adverb>().Count()); }
public void RemovingExplanation_FromWord_WillUpdateDB() { var word = WordsService.GetWordsWithData().First(); var before = word.Explanations.Count(); word.Explanations = null; WordsService.Update(word); var newWord = WordsService.GetWordsWithData().First(); Assert.IsTrue(newWord.Explanations == null || newWord.Explanations.Count == 0, "Explanations should be empty"); }
public async Task GetAllWordsAsync_ReturnsAllFromSet() { const int expectedCount = 3; var ids = (await FeedTestData(_context, expectedCount)).OfType <Noun>().Select(w => w.Id).ToList(); var service = new WordsService(_context); var actual = await service.GetAllWordsAsync <Noun>("en"); Assert.Equal(expectedCount, actual.Count); actual.Select(w => w.Id).Should().Equal(ids); }
//TODO: use nhibernate join private async void LoadWordsCollection(NHibernate.Criterion.ICriterion expression = null) { var allWords = new List <Word>(); WordsCollection.Clear(); var collection = await WordsService.GetDataAsync <Word>(expression); if (collection != null) { foreach (var item in collection) { if (!allWords.Exists(x => x.Id == item.Id)) { allWords.Add(item); } } } foreach (var item in allWords) { WordsCollection.Add(new WordViewModel { WordToDisplay = item }); } var alreadyAdded = allWords.Count; //only in case of searching it does matter if (expression != null) { var collection2 = await WordsService.GetDataAsync <Translation>(expression); if (collection2 != null) { foreach (var item in collection2) { foreach (var w in item.WordsStoredIn) { if (!allWords.Exists(x => x.Id == w.Id)) { allWords.Add(w); } } } } } foreach (var item in allWords.Skip(alreadyAdded)) { WordsCollection.Add(new WordViewModel { WordToDisplay = item }); } allWords = null; }
public void RemovingLink_BetweenTwoWords_WillRelinkWordsInBooks( [Values(true, false)] bool enBookLang, [Values(true, false)] bool invertRemoval) { // Arrange var langEn = new Language("English"); var langEsp = new Language("Spanish"); var masterA = new MasterWord(); var wordA = new Word(masterA, "Hi", langEn); var wordB = new Word(masterA, "Hola", langEsp); new Word(masterA, "some word", new Language("some lang")); var book = new Book("name", enBookLang ? langEn : langEsp); book.AddWord(masterA); MasterWordsService.Add(masterA); BooksService.Add(book); // Act RefreshServicesAndClearCache(); wordA = WordsService.GetAll().First(w => w.ID == wordA.ID); wordB = WordsService.GetAll().First(w => w.ID == wordB.ID); if (invertRemoval) { WordsService.RemoveTranslation(wordA, wordB); } else { WordsService.RemoveTranslation(wordB, wordA); } // Assert book = BooksService.Get(book.ID); Assert.AreEqual(1, book.WordCount, "Book word count should be 1. Old Ref"); Assert.AreEqual(1, book.WordCount, "Book word count should be 1. New Ref"); Assert.IsNotNull(book.Words.First()[book.Language], "After removing translation between two words, book should keep the master word which aligns with book language. New Ref"); var wordInBook = enBookLang ? wordA : wordB; var wordWithoutBook = enBookLang ? wordB : wordA; Assert.AreEqual(book, wordInBook.MasterWord.Books.First(), "word should be in a book"); Assert.AreEqual(book.Language, wordInBook.Language, "book and word languages should be the same"); Assert.AreEqual(book.Words.First(), wordInBook.MasterWord, "master word should be the same of word left of correct language"); Assert.AreEqual(0, wordWithoutBook.MasterWord.Books.Count(), "other word should have no books"); }
public async Task GetWordByIdAsync_ReturnsWordIfFound() { var expected = (await FeedTestData(_context, 3)).OfType <Adverb>().First(); var service = new WordsService(_context); var actual = await service.GetWordByIdAsync <Adverb>(expected.Id); Assert.NotNull(actual); Assert.IsType <Adverb>(actual); Assert.Equal(expected.Id, actual.Id); Assert.Equal(expected.Value, actual.Value); }
public async Task DeleteWordsAsync_ReturnsIdSetOfDeletedWhenExist() { const int count = 5; const int deletedCount = 3; var expected = (await FeedTestData(_context, count)).OfType <Noun>().Skip(count - deletedCount).ToList(); var service = new WordsService(_context); var actual = await service.DeleteWordsAsync(expected); Assert.Equal(deletedCount, actual.Count); Assert.Equal(count - deletedCount, _context.Set <Noun>().Count()); actual.Should().Equal(expected.Select(w => w.Id)); }
public async Task DeleteWordAsync_ReturnsZeroWhenDoesNotExist() { const int count = 3; var nonExistent = (await FeedTestData(_context, count)).OfType <Adjective>().First(); nonExistent.Id = int.MaxValue; var service = new WordsService(_context); var actual = await service.DeleteWordAsync(nonExistent); Assert.Equal(0, actual); Assert.Equal(count, _context.Set <Adjective>().Count()); }