public void GetAnagrams_ContainsMultipleAnagrams_ReturnsMultipleAnagrams()
{
var result = _anagramSolver.GetAnagrams("alus");
Assert.That(result.Count == 2);
Assert.That(result.Contains("salu"));
Assert.That(result.Contains("sula"));
}
public void TestIfIndexReturnsNeededResult()
{
//Arrange
anagramSolver = Substitute.For <IAnagramSolver>();
var anagramList = new List <string>()
{
"kalnas", "klanas", "lankas", "skalna"
};
anagramSolver.GetAnagrams(Arg.Any <string>()).Returns(anagramList);
var controller = new HomeController(anagramSolver, databaseLogic, eflogic,
efWordRepository, efUserLogRepository, efCachedWordRepository);
var result = controller.Index("kalnas");
//Act
anagramSolver.Received().GetAnagrams(Arg.Any <string>());
//Assert
CollectionAssert.Contains(anagramList, result);
////Arrange
//var anagramList = anagramSolver.GetAnagrams("kalnas");
//var controller = new HomeController(anagramSolver);
//var result = controller.Index("kalnas");
////Assert
//CollectionAssert.Contains(anagramList, result);
}
public async Task IndexSuccessWhenSearchingDBForResult()
{
var returnList = new List <string>()
{
"word1", "word2"
};
_userLogServiceMock.CountAnagramsLeftForIpToSolve().Returns(5);
_searchHistoryServiceMock.GetSearchedAnagrams(Arg.Any <string>()).Returns((List <string>)null);
_anagramSolverMock.GetAnagrams(Arg.Any <string>()).Returns(returnList);
await _userLogServiceMock.AddLog(Arg.Any <TimeSpan>(), Arg.Any <UserActionTypes>(), Arg.Any <string>());
_cookiesHandlerServiceMock.AddCookie(Arg.Any <string>(), Arg.Any <string>());
await _contextMock.SaveChangesAsync();
var result = await _controller.Index("labas") as ViewResult;
var data = result.ViewData.Model as List <string>;
await _userLogServiceMock.Received().CountAnagramsLeftForIpToSolve();
await _searchHistoryServiceMock.Received().GetSearchedAnagrams(Arg.Any <string>());
await _anagramSolverMock.Received().GetAnagrams(Arg.Any <string>());
await _userLogServiceMock.Received().AddLog(Arg.Any <TimeSpan>(), Arg.Any <UserActionTypes>(), Arg.Any <string>());
_cookiesHandlerServiceMock.Received().AddCookie(Arg.Any <string>(), Arg.Any <string>());
await _contextMock.Received().SaveChangesAsync();
Assert.AreEqual(returnList.Count, data.Count);
Assert.AreEqual(returnList[0], data[0]);
Assert.AreEqual(returnList[1], data[1]);
}
public AnagramsSearchInfoModel GetAnagrams(string requestWord, string userIp)
{
var anagramsSearchInfoModel = new AnagramsSearchInfoModel();
if (!_userManagingService.CheckIfRegistered(userIp))
{
_userContract.SetUser(userIp);
}
anagramsSearchInfoModel.isValidToSearch = _userManagingService.CheckIfValidToSearch(userIp);
if (!anagramsSearchInfoModel.isValidToSearch)
{
return(anagramsSearchInfoModel);
}
if (_cachedWords.CheckIfCached(requestWord))
{
_logger.Log(requestWord, userIp);
anagramsSearchInfoModel.Anagrams = _cachedWords.GetCachedAnagrams(requestWord);
return(anagramsSearchInfoModel);
}
anagramsSearchInfoModel.Anagrams = _anagramSolver.GetAnagrams(requestWord).ToList();
_requestWordContract.SetRequestWord(requestWord);
_cachedWords.SetCachedAnagrams(anagramsSearchInfoModel.Anagrams, requestWord);
_logger.Log(requestWord, userIp);
return(anagramsSearchInfoModel);
}
public async Task ProcessAnagramManager()
{
bool exit = false;
string myWord;
while (!exit)
{
myWord = WriteWord();
if (myWord == "x" || myWord == "X")
{
break;
}
if (!UILogic.CheckIfLengthCorrect(myWord))
{
OnPrint("\nĮvestas žodis per trumpas");
continue;
}
OnPrint("Anagramos:\n");
var anagramsobject = await _apiService.GetAnagrams(myWord);
var anagrams = anagramsobject.Select(x => x.Word);
DisplayAnagrams(anagrams);
}
OnPrint("Darbas baigtas!");
}
// Keiciama is static void Main i static async Task kad kviest async
static async Task Main(string[] args)
{
// 1- Ar uzpildyti lentele
//**//DB
//_userInterface.ToFillTable();
var minInputWordLength = Configuration.BuilderConfigurations();
var input = _userInterface.GetUserInput(minInputWordLength);
var anagrams = _anagramSolver.GetAnagrams(input);
Console.WriteLine("---Anagramos:");
Console.WriteLine(string.Join('\n', anagrams));
// Get anagrams response by making API request
Console.WriteLine("---API request:");
var inputForRequest = _userInterface.GetUserInput(minInputWordLength);
var responseAnagrams = await _userInterface.RequestAPI(inputForRequest);
Console.WriteLine("---API Response anagramos:");
Console.WriteLine(responseAnagrams);
//+++ Configuration klase , o metodas AnagramValidator, sukurt objekta pries tai.
// Ideti validavima i try catch catch --> Console.. ArgumentException
}
public string GetAnagrams(string word)
{
IList <string> anagrams = anagramSolver.GetAnagrams(word, HttpContext.Connection.LocalIpAddress.MapToIPv4().ToString());
string json = JsonConvert.SerializeObject(anagrams);
return(json);
}
public IList <Anagram> GetAnagrams(string word, string ipAddress)
{
var freeSearchesCount = Convert.ToInt32(_appConfig.GetConfiguration()["FreeSearchesCount"]);
var user = _usersRepository
.GetUsers()
.FirstOrDefault(u => u.Ip == ipAddress);
if (user == null)
{
_usersRepository.AddUser(new User {
Ip = ipAddress
});
user = _usersRepository
.GetUsers()
.FirstOrDefault(u => u.Ip == ipAddress);
}
if (user.SearchesLeft > 0)
{
return(_anagramSolver.GetAnagrams(word, user));
}
throw new Exception("You exceeded free searched limit, please add new word");
}
public void TestAnagramsReturnFromSingleWord(string inputWord, string expectedAnagram)
{
//Act
IEnumerable <string> output = _anagramSolver.GetAnagrams(inputWord);
//Assert
CollectionAssert.Contains(output, expectedAnagram);
}
public void Should_Use_Anagrams_Cache_Only(string word, string userIp)
{
_cacheRepository.GetCachedAnagrams(word).Returns(new List <WordModel>()
{
new WordModel(word)
});
_wordsRepository.GetWords().Returns(_dummyWordsRepository.GetWords());
_anagramSolver.GetAnagrams(word, _dummyWordsRepository.GetWords()).Returns(new List <WordModel>()
{
new WordModel(word)
});
_anagramsService.GetAnagrams(word, userIp);
_cacheRepository.Received().GetCachedAnagrams(word);
_wordsRepository.DidNotReceive().GetWords();
_anagramSolver.DidNotReceive().GetAnagrams(word, _wordsRepository.GetWords());
}
public void GetAnagrams_ReturnsAllAnagramsForAWord()
{
_appConfig.GetConfiguration()["FreeSearchesCount"].Returns("5");
_usersRepository.GetUsers().Returns(new List <User>
{
new User {
Id = 1, Ip = "::1", SearchesLeft = 5
},
new User {
Id = 2, Ip = "::2", SearchesLeft = 4
},
new User {
Id = 3, Ip = "::3", SearchesLeft = 3
},
new User {
Id = 4, Ip = "::4", SearchesLeft = 2
}
});
_anagramSolver.GetAnagrams(Arg.Is <string>("Dievas"), Arg.Is <User>(_usersRepository.GetUsers().First()))
.Returns(new List <Anagram>
{
new Anagram {
Id = 1, Text = "veidas"
},
new Anagram {
Id = 1, Text = "deivas"
},
new Anagram {
Id = 1, Text = "viedas"
}
});
var anagrams = _anagramsService.GetAnagrams("Dievas", "::1");
_usersRepository.Received(2).GetUsers();
_anagramSolver.Received(1).GetAnagrams(Arg.Is <string>("Dievas"), Arg.Is <User>(_usersRepository.GetUsers().First()));
anagrams.ShouldNotBeNull();
anagrams.Count.ShouldBe(3);
anagrams.ElementAt(0).Text.ShouldBe("veidas");
anagrams.ElementAt(1).Text.ShouldBe("deivas");
anagrams.ElementAt(2).Text.ShouldBe("viedas");
}
public List <string> CacheAnagrams(string input)
{
var sortedWord = input.Alphabetize();
List <string> anagrams = _cachedWordsRepository.GetCachedAnagrams(sortedWord);
if (!anagrams.Any())
{
anagrams = _anagramSolver.GetAnagrams(input);
_cachedWordsRepository.WriteCachedWord(sortedWord, anagrams);
}
return(anagrams);
}
public async Task GetSuccessWhenWordDefiled()
{
_anagramSolverMock.GetAnagrams(Arg.Any <string>()).Returns(_stringList);
var result = await _controller.Get("abc") as ObjectResult;
var data = result.Value as List <string>;
await _anagramSolverMock.Received().GetAnagrams(Arg.Any <string>());
Assert.AreEqual(_stringList.Count, data.Count);
Assert.AreEqual(_stringList[0], data[0]);
}
public async Task <IActionResult> Index([Required] string id)
{
try
{
if (string.IsNullOrEmpty(id))
{
return(View());
}
IList <string> anagrams = new List <string>();
var solvesLeft = await _userLogService.CountAnagramsLeftForIpToSolve();
if (solvesLeft <= 0)
{
throw new Exception("You reached your solve limit. Add new word to increase your limit");
}
anagrams = await _searchHistoryService.GetSearchedAnagrams(id);
if (anagrams != null && anagrams.Count > 0)
{
return(View(anagrams));
}
Stopwatch sw = new Stopwatch();
sw.Start();
anagrams = await _anagramSolver.GetAnagrams(id);
sw.Stop();
await _userLogService.AddLog(sw.Elapsed, UserActionTypes.GetAnagrams, id);
//removing input element
anagrams.Remove(id);
_cookiesHandler.AddCookie(id, string.Join(";", anagrams.ToArray()));
await _context.SaveChangesAsync();
return(View(anagrams));
}
catch (Exception ex)
{
@ViewData["Error"] = ex.Message;
return(View());
}
}
public IActionResult Index(string word)
{
try
{
if (string.IsNullOrEmpty(word))
{
throw new Exception("Error! At least one word must be entered.");
}
var ip = HttpContext.Connection.RemoteIpAddress.ToString();
var validationCheck = CheckSearchValidation(ip);
if (validationCheck != "ok")
{
ViewBag.Message = "Limit of searches was exceeded! In order to have more searches, add these pages:";
return(View());
}
else
{
_efUserLogRepository.InsertUserLog(word, ip, UserAction.Search);
////var check = _databaseLogic.GetCachedWords(id);
var check = _efCachedWordRepository.GetCachedWords(word);
if (check.Count == 0)
{
var anagrams = _anagramSolver.GetAnagrams(word);
//var anagramsId = _databaseLogic.GetAnagramsId(anagrams);
var anagramsId = _efWordRepository.GetAnagramsId(anagrams);
//_databaseLogic.InsertCachedWords(id, anagramsId);
_efCachedWordRepository.InsertCachedWords(word, anagramsId);
return(View(anagrams));
}
else
{
//var anagramsFromCache = _databaseLogic.GetCachedWords(id);
var anagramsFromCache = _efCachedWordRepository.GetCachedWords(word);
return(View(anagramsFromCache));
}
}
//return View(anagrams);
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(word));
}
}
public IActionResult Index(string word)
{
AddCookie();
if (word == null)
{
return(new EmptyResult());
}
WordViewModel wordViewModel = new WordViewModel();
wordViewModel.Name = word;
string ip = HttpContext.Connection.LocalIpAddress.MapToIPv4().ToString();
wordViewModel.Anagrams = anagramService.GetAnagrams(word, ip);
return(View(wordViewModel));
}
static async Task Main(string[] args)
{
if (File.Exists(@"ConsoleLog.txt"))
{
File.Delete(@"ConsoleLog.txt");
}
//events
DisplayWithEvents _userInterface = new DisplayWithEvents();
_userInterface.PrintEvent += WriteToConsole;
_userInterface.PrintEvent += WriteToFile;
//loading data from settings file
Configuration.ReadAppSettingsFile();
var howToSolve = _userInterface.DisplayOptions();
while (true)
{
if (howToSolve == 0)
{
await SeedDBWithFileData();
}
//getting initial user input
var userInput = _userInterface.GetInput();
if (userInput == null)
{
break;
}
List <string> result;
if (howToSolve == 2)
{
result = (List <string>) await _anagramSolver.GetAnagrams(userInput);
}
else
{
result = await _apiActions.CallAnagramSolverApi(userInput);
}
_userInterface.DisplayResults(result);
}
}
public void GetAnagrams_ContainsAnagram_ReturnsOneAnagram()
{
fileText = "sala a sala 1";
using (StreamWriter sw = new StreamWriter(fileName))
{
sw.WriteLine(fileText);
}
_wordRepository = new FileWordRepository(@"C:\Users\Julius\source\repos\MainApp\Implementation.AnagramSolver.Tests\bin\Debug\netcoreapp2.1\" + fileName);
_anagramSolver = new AnagramSolverSingleWord(_wordRepository);
var result = _anagramSolver.GetAnagrams("alas");
Assert.That(result.Count == 1);
Assert.That(result.First() == "sala");
}
public IList <string> Get(string input)
{
var splitInput = input.Split(" "); // put the strings seperated by spaces into an array so they can be passed to the GetAnagrams function // need to find a better workaround
bool success = int.TryParse(ConfigurationManager.AppSettings["MaxResultAmount"], out var _defaultValue);
if (!success)
{
_defaultValue = 100;
}
var resultList = new AnagramViewModel {
WordList = anagramSolver.GetAnagrams(splitInput)
};
return(resultList.WordList);
}
public IActionResult Get(string id)
{
try
{
if (string.IsNullOrEmpty(id))
{
throw new Exception("Error! At least one word must be entered.");
}
var anagrams = _anagramSolver.GetAnagrams(id);
return(Ok(anagrams));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void Index_ShouldReturnAView()
{
string word = "dangus";
string ip = "107.0.0.1";
var headerDictionary = new HeaderDictionary();
httpResponse.Headers.Returns(headerDictionary);
httpContext.Response.Returns(httpResponse);
httpContext.Connection.LocalIpAddress.Returns(new System.Net.IPAddress(new Byte[] { 107, 0, 0, 1 }));
anagramService.GetAnagrams(word, ip).Returns(new List <string> {
"dugnas", "gandus"
});
var result = homeController.Index(word);
Assert.IsInstanceOf <ViewResult>(result);
anagramService.Received().GetAnagrams(word, ip);
}
public bool Run(bool continueRunning)
{
if (continueRunning)
{
Console.WriteLine("Please enter > 0 and < 11 words");
var inputWords = Console.ReadLine();
var wordCount = inputWords.Split(' ').Length;
if (wordCount >= 1 && wordCount <= 10)
{
var anagrams = _anagramSolver.GetAnagrams(inputWords, null);
_printer.Print(new List <IPrintable> {
new Anagrams(anagrams)
});
}
}
return(continueRunning);
}
public void GetAnagrams_IfWordIsNotCached_ShouldSetAnagramsToCache()
{
List <string> anagrams = new List <string> {
"sula", "alus"
};
_cachedWords.CheckIfCached("test").Returns(false);
//_cachedWords.GetCachedAnagrams("test").Returns(anagrams);
_userManagingService.CheckIfValidToSearch(ip).Returns(true);
_anagramSolver.GetAnagrams("test").Returns(anagrams);
var result = _anagramsSearchService.GetAnagrams("test", ip);
_cachedWords.DidNotReceive().GetCachedAnagrams("test");
_logger.Received().Log("test", ip);
result.Anagrams.ShouldBe(anagrams);
_anagramSolver.Received().GetAnagrams("test");
_cachedWords.Received().SetCachedAnagrams(result.Anagrams, "test");
}
public void GetAnagrams_ShouldReturnAnagramsFromSolverAndCacheThem()
{
var word = "alus";
var sortedWord = "alsu";
var list = new List <string>
{
"alus",
"sula"
};
_cachedWordsRepository.GetCachedAnagrams(sortedWord).Returns(new List <string> {
});
_anagramSolver.GetAnagrams(word).Returns(list);
var result = _cachedAnagramsService.CacheAnagrams(word);
result.ShouldNotBeNull();
result.First().ShouldBe(list[0]);
_cachedWordsRepository.Received().WriteCachedWord(sortedWord, Arg.Is <List <string> >(x => x.SequenceEqual(list)));
}
public IActionResult WordAnagrams(string id)
{
try
{
if (string.IsNullOrEmpty(id))
{
throw new Exception("Error! At least one word must be entered.");
}
var anagrams = _anagramSolver.GetAnagrams(id);
return(View(anagrams));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(id));
}
}
public void GetAnagrams_ShouldReturnCorrectAnagrams()
{
string word = "dangus";
string ip = "107.0.0.1";
List <string> anagrams = new List <string> {
"dugnas", "gandus"
};
string expected = JsonConvert.SerializeObject(anagrams);
var headerDictionary = new HeaderDictionary();
httpResponse.Headers.Returns(headerDictionary);
httpContext.Response.Returns(httpResponse);
httpContext.Connection.LocalIpAddress.Returns(new System.Net.IPAddress(new Byte[] { 107, 0, 0, 1 }));
anagramService.GetAnagrams(word, ip).Returns(anagrams);
var result = dataController.GetAnagrams(word);
Assert.AreEqual(expected, result);
anagramService.Received().GetAnagrams(word, ip);
}
public List <WordResponseModel> GetAnagrams(string word, string ip)
{
try
{
_usersRepository.DecreaseAvailabeUserSearches(ip);
} catch (Exception ex)
{
throw;
}
List <WordModel> anagrams;
if (IsCached(word))
{
anagrams = _cachedAnagrams;
}
else
{
anagrams = _anagramSolver.GetAnagrams(word, _wordsRepository.GetWords());
UpdateAnagramsCache(word, anagrams);
}
return(anagrams.Select(w => new WordResponseModel(w.word, w.Id)).ToList());
}
public async Task <IActionResult> Get(string word)
{
try
{
if (string.IsNullOrEmpty(word))
{
throw new Exception("You must enter at least one word");
}
var anagrams = await _anagramSolver.GetAnagrams(word);
//removing input element
anagrams.Remove(word);
//saves inserted cached word
await _context.SaveChangesAsync();
return(Ok(anagrams));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public List <string> GetAnagrams(string id)
{
return(_anagramSolver.GetAnagrams(id).ToList());
}
public void GetAnagramsFailedWhenInputDoNotPassValidation()
{
Assert.ThrowsAsync <Exception>(
async() => await _anagramSolver.GetAnagrams(null));
}