public void CanSayHello()
{
//Arrange
var settings = new Mock <IOptions <ApplicationSettings> >();
settings
.SetupGet(s => s.Value)
.Returns(new ApplicationSettings
{
Greeter = "MyGreeter",
GreetingFormat = "Hello {0} from {1}"
});
var repository = new WordRepository(settings.Object);
const string recipient = "User";
const int iterations = 2;
const string expectedResult = "Hello User from MyGreeter";
//Act
var result = repository.SayHello(recipient, iterations);
//Assert
var list = result.ToList();
Assert.Equal(2, list.Count);
Assert.True(list.All(l => l == expectedResult));
}
public void Can_Add_Word()
{
// Get a CollectionId to add to
var collectionId = 2;
// Make word
var word = new Word()
{
UserId = 1,
CollectionId = 2,
MwWordId = "12345",
Name = "Added",
LastViewed = DateTime.Now - TimeSpan.FromDays(15)
};
// Instantiate Word Repo
var repo = new WordRepository(_context);
// Get a count of words in Collection
var originalCount = repo.GetByCollectionId(collectionId).Count;
// Add items
repo.Add(word);
// Get new count
var newCount = repo.GetByCollectionId(collectionId).Count;
// New count should be +1 original
Assert.True(newCount == originalCount + 1);
}
public void Deserialize_FileDoesNotExist_Throws()
{
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>());
WordRepository repo = new WordRepository(fileSystem.FileSystem, "words.txt");
Assert.Throws <FileNotFoundException>(() => repo.Deserialize(5));
}
public WordSquare(WordSquare source)
{
Size = source.Size;
Lines = new string[Size];
Array.Copy(source.Lines, Lines, source.Lines.Length);
Repository = source.Repository;
}
public void RemovesExpectedWord()
{
//arrange
string fileNameForThisTest = $@"c:\temp\testFile_{Thread.CurrentThread.ManagedThreadId}.txt";
using (var stream = File.CreateText(fileNameForThisTest))
{
stream.WriteLine("first");
stream.WriteLine("second");
stream.WriteLine("third");
stream.Flush();
}
var initialText = File.ReadAllText(fileNameForThisTest);
Assert.AreEqual(@"first
second
third
", initialText);
//act
WordRepository repository = new WordRepository();
repository.RemoveWordFromFile("second", fileNameForThisTest);
//assert
var modifiedText = File.ReadAllText(fileNameForThisTest);
Assert.AreEqual(@"first
third
", modifiedText);
}
private void Import_Click(object sender, RoutedEventArgs e)
{
System.Windows.Forms.OpenFileDialog openFileDialog = new System.Windows.Forms.OpenFileDialog();
if (openFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
var filepath = openFileDialog.FileName;
var excelDomain = this.ExcelUtil.ImportTemplate(filepath);
var title = excelDomain.TitleList.FirstOrDefault().Title;
if (string.IsNullOrEmpty(title) || !mappingDic.ContainsKey(title))
{
MessageBox.Show("The template name is invalid");
}
else
{
this.TableName = mappingDic[title];
this.wordRepository = new WordRepository(this.TableName);
var wordList = this.ConvertExcelDomainToWordDomain(excelDomain);
// save to db
var errorList = this.wordRepository.InsertAll(wordList);
if (errorList != null && errorList.Any())
{
this.AddErrorToExcelDomain(errorList, ref excelDomain);
this.ExcelUtil.ExcelDomain = excelDomain;
this.ExcelUtil.DownloadTemplate(true);
}
}
}
}
public void CreateSeedData()
{
using (var ctx = new SpellCheckerContext())
{
var sb = new StringBuilder("Words = new List<SpellChecker.Dal.DomainObjects.Word>");
sb.AppendLine("{");
var repository = new WordRepository(ctx);
var words = repository.All.Where(w => w.SpellingBeeTestId.Equals(1)).ToList();
foreach (var word in words)
{
sb.AppendLine(string.Format("new SpellChecker.Dal.DomainObjects.Word {{ EnglishText = \"{0}\", SwedishText = \"{1}\" }},", word.EnglishText, word.SwedishText));
}
sb.AppendLine("}");
using (var sw = new StreamWriter(@"c:\xml\spellchecker\words.cs"))
{
sw.Write(sb.ToString());
}
}
/*
*
* Words = new List<SpellChecker.Dal.DomainObjects.Word>
* {
* new SpellChecker.Dal.DomainObjects.Word { EnglishText = "monday", SwedishText = "måndag" },
* new SpellChecker.Dal.DomainObjects.Word { EnglishText = "tuesday", SwedishText = "tisdag" },
* new SpellChecker.Dal.DomainObjects.Word { EnglishText = "wednesday", SwedishText = "onsdag" },
* new SpellChecker.Dal.DomainObjects.Word { EnglishText = "thursday", SwedishText = "torsdag" },
* new SpellChecker.Dal.DomainObjects.Word { EnglishText = "friday", SwedishText = "fredag" },
* new SpellChecker.Dal.DomainObjects.Word { EnglishText = "saturday", SwedishText = "lördag" },
* new SpellChecker.Dal.DomainObjects.Word { EnglishText = "sunday", SwedishText = "söndag" }
* }
*/
}
public UnitOfWork(EFDbContext context)
{
_context = context;
DictionaryRepository = new DictionaryRepository(context);
UserRepository = new UserRepository(context);
WordRepository = new WordRepository(context);
}
// ReSharper disable IdentifierTypo
public void ZZZZ_IsNotAWord()
// ReSharper restore IdentifierTypo
{
WordRepository repository = new WordRepository();
Assert.AreEqual(WordCategory.NotAWord, repository.CategorizeWord("zzzz"));
}
public LettersAndArrowsPuzzle(string solution, bool rowsMustFormWords = false, int sizeOverride = 0, int randomSeed = 0)
{
RandomSeed = randomSeed;
RowsMustFormWords = rowsMustFormWords;
if (RowsMustFormWords)
{
Size = 4;
Repository = new WordRepository()
{
ExcludeAdvancedWords = true
};
}
else
{
Size = CalculateSizeBasedOnSolutionLength(solution.Length);
Repository = new WordRepository()
{
ExcludeAdvancedWords = true
};
}
if (sizeOverride != 0)
{
Size = sizeOverride;
}
InitializeGrid();
_clues = new string[Size];
PlaceSolution(solution);
FillEmptyCells();
}
public InputViewModel(GameState gameState, WordRepository wordRepository, Settings settings,
WordGameViewModel wordGameViewModel)
{
_wordRepository = wordRepository;
_settings = settings;
_words = _wordRepository.Deserialize(settings.WordSize);
_random = new Random();
BingoSetupViewModel1 = new BingoSetupViewModel(gameState.Team1);
BingoSetupViewModel2 = new BingoSetupViewModel(gameState.Team2);
WordInputViewModel = new WordInputViewModel(_words, settings, _random, wordGameViewModel);
FocusTeam1 = ReactiveCommand.Create(() => Unit.Default);
FocusTeam2 = ReactiveCommand.Create(() => Unit.Default);
FocusBingoCard = ReactiveCommand.Create(() => Unit.Default);
FocusWordGame = ReactiveCommand.Create(() => Unit.Default);
FocusTeam1.Subscribe(x =>
{
TeamWithFocus = 1;
if (GameSectionWithFocus == GameSection.Bingo)
{
SelectedViewModel = BingoSetupViewModel1;
}
});
FocusTeam2.Subscribe(x =>
{
TeamWithFocus = 2;
if (GameSectionWithFocus == GameSection.Bingo)
{
SelectedViewModel = BingoSetupViewModel2;
}
});
FocusBingoCard.Subscribe(x =>
{
GameSectionWithFocus = GameSection.Bingo;
if (WordInputViewModel.StateInfo != null && WordInputViewModel.StateInfo.State == WordGameState.Won)
{
WordInputViewModel.Clear();
}
if (TeamWithFocus == 1)
{
SelectedViewModel = BingoSetupViewModel1;
return;
}
SelectedViewModel = BingoSetupViewModel2;
});
FocusWordGame.Subscribe(x =>
{
GameSectionWithFocus = GameSection.Word;
SelectedViewModel = WordInputViewModel;
});
SelectedViewModel = BingoSetupViewModel1;
}
public WhenGettingWord()
{
_wordToSearch = "search";
_result = WordRepository.GetByAsync(w =>
w.Value.Equals(_wordToSearch, StringComparison.OrdinalIgnoreCase))
.Result;
}
public async Task Should_Get_Same_Item()
{
var _result = await WordRepository.GetByAsync(w => w.Id.Equals(Word.Id));
_result.Should().NotBeNull();
_result.Should().Be(Word);
}
public CommentService(CommentRepository cr, EnglishStemmer es, WordRepository wr, ResourceRepository rr)
{
_commentRepo = cr;
_stemmer = es;
_wRepo = wr;
_rRepo = rr;
}
public void PopulatesExpectedLists()
{
WordRepository wordRepository = new WordRepository();
wordRepository.LoadAllWords();
Assert.IsTrue(wordRepository.IsAWord("zooms"));
}
public void LoadData(DateTime fromDate, DateTime toDate)
{
ResetSearchBar();
cellList = new List <LexiconItemViewModel> ();
var wordRepository = new WordRepository();
var items = wordRepository.GetItemsFromTo(fromDate, toDate);
foreach (var word in items)
{
var item = new LexiconItemViewModel()
{
NewWord = word.Word,
WordMeaning = word.Meaning,
Note = word.Note,
Example = word.Example,
WordFormation = word.WordFormation,
ClientId = word.ClientId,
Index = items.IndexOf(word) + 1,
Collocation = word.Collocation,
Synonym = word.Synonym,
Antonym = word.Antonym,
WordType = word.WordType
};
cellList.Add(item);
}
base.LoadData(cellList);
}
public void WordLengthSix_ReturnsWordOfExpectedLength()
{
WordRepository repository = new WordRepository();
string randomWord = repository.GetRandomWord(6);
Debug.WriteLine(randomWord);
Assert.AreEqual(6, randomWord.Length, $"Unexpected Random word '{randomWord}'");
}
public void Should_Have_Updated_Value()
{
var word = WordRepository
.GetByAsync(w => w.Value.Equals(_wordToUpdate))
.Result;
word.Count.Should().Be(_initialCount + 1);
}
public void IndexerTest()
{
WordRepository target = new WordRepository(string.Format("ahoj{0}cau{0}ako{0}", Environment.NewLine));
Assert.AreEqual("ahoj", target[0]);
Assert.AreEqual("cau", target[1]);
Assert.AreEqual("ako", target[2]);
}
public void BLUE_ReturnsExpectedResults()
{
WordRepository repository = new WordRepository();
List <string> results = repository.FindThemesForWord("blue");
Console.WriteLine(string.Join(Environment.NewLine, results));
Assert.AreEqual(2, results.Count);
}
public UnitOfWork(global::SQLite.Net.Interop.ISQLitePlatform platform, string pathToDatabase)
{
var connection = new SQLiteConnection(platform, pathToDatabase);
CreateTables(connection);
Words = new WordRepository(connection);
Sections = new SectionRepository(connection);
}
public WordsService(UserWordPairRepository userWordPairRepository,
WordPairRepository wordPairRepository,
WordRepository wordRepository)
{
this.userWordPairRepository = userWordPairRepository;
this.wordPairRepository = wordPairRepository;
this.wordRepository = wordRepository;
}
private void GivenInvalidServiceUrl()
{
_configurationAdapterMock
.Setup(e => e.Config(WordRepository.SERVICE_URL_CONFIG_KEY))
.Returns("http://funny-invalid-url.none/");
_repository = new WordRepository(_configurationAdapterMock.Object);
}
public void Init()
{
_configurationAdapterMock = new Mock <IConfigurationAdapter>();
_configurationAdapterMock
.Setup(e => e.Config(WordRepository.SERVICE_URL_CONFIG_KEY))
.Returns("http://teste.way2.com.br/dic/api/words/");
_repository = new WordRepository(_configurationAdapterMock.Object);
}
public void ZESTFUL_IsAWord()
{
WordRepository repository = new WordRepository()
{
ExcludeAdvancedWords = true
};
Assert.IsTrue(repository.IsAWord("zestful"));
}
public void SISTER_IsAWord()
{
WordRepository repository = new WordRepository()
{
ExcludeAdvancedWords = false
};
Assert.IsTrue(repository.IsAWord("sister"));
}
public void OUTBREAK_IsAWord()
{
WordRepository repository = new WordRepository()
{
ExcludeAdvancedWords = true, IgnoreCache = true
};
Assert.IsTrue(repository.IsAWord("outbreak"));
}
public void TRAMPOLINE_IsAWord()
{
WordRepository repository = new WordRepository()
{
ExcludeAdvancedWords = true
};
Assert.IsTrue(repository.IsAWord("trampoline"));
}
public void OnlyBasic_Excludes_ASP()
{
WordRepository repository = new WordRepository()
{
ExcludeAdvancedWords = true
};
Assert.IsFalse(repository.IsAWord("asp"));
}
public void GetAllWords()
{
using (var ctx = new SpellCheckerContext())
{
var repository = new WordRepository(ctx);
var all = repository.All;
Assert.IsTrue(all.ToList().Count.Equals(100));
}
}
public UnitOfWork(DbContextDictionaryOfWords contextDictionaryOfWords)
{
_contextDictionaryOfWords = contextDictionaryOfWords;
_repositories = new ConcurrentDictionary <Type, object>();
Language = new LanguageRepository(contextDictionaryOfWords);
Word = new WordRepository(contextDictionaryOfWords);
WordTranslation = new WordTranslationRepository(contextDictionaryOfWords);
}
