public async Task GetAllAnswersForAQuestionById_WithCorrectData_ShouldReturnCorrectResult()
{
string errorMessagePrefix = "AnswersService Method GetAllAnswersForQuestionById() does not work properly.";
var context = CDGBulgariaInmemoryFactory.InitializeContext();
await SeedData(context);
this.answersService = new AnswersService(context);
List <AnswerServiceModel> expectedResults = GetInitialData().Where(a => a.QuestionId == "trtsjjsch567jscj").To <AnswerServiceModel>().ToList();
List <AnswerServiceModel> actualResults = this.answersService.GetAllAnswersForAQuestionById("trtsjjsch567jscj")
.To <AnswerServiceModel>()
.ToList();
Assert.True(expectedResults.Count == actualResults.Count, errorMessagePrefix);
for (int i = 0; i < expectedResults.Count; i++)
{
var expectedEntry = expectedResults[i];
var actualEntry = actualResults[i];
Assert.True(expectedEntry.Content == actualEntry.Content, errorMessagePrefix + " " + " Content is not returned properly");
Assert.True(expectedEntry.QuestionId == actualEntry.QuestionId, errorMessagePrefix + " " + "QuestionId is not returned properly");
Assert.True(expectedEntry.AuthorId == actualEntry.AuthorId, errorMessagePrefix + " " + "AuthorId is not returned properly");
}
}
public void GetQuestionAnswers_WhenQuestionDoesNotExist_ShouldReturnEmptyList()
{
var answers = new List <TaskAnswer>()
{
new TaskAnswer
{
Id = "id1",
IsCorrect = true,
Location = "location 1",
Answer = "asnwer 1",
IsDeleted = false
},
new TaskAnswer
{
Id = "id2",
IsCorrect = false,
Location = "location 2",
Answer = "asnwer 2",
IsDeleted = false
}
};
taskAnswersRepositoryMock.Setup(s => s.GetAnswersByQuestion("questionId")).Returns(answers);
var service = new AnswersService(mapper, taskAnswersRepositoryMock.Object);
var results = service.GetQuestionAnswers("NotExistantId");
results.ShouldNotBeNull();
results.Count().ShouldBe(0);
}
public async Task AddItemAsync()
{
//Arrange
// var mock = new Mock<AnswersService>();
// mock.Setup(x => x.AddItemAsync(answer1).Result).Returns(answer1.Id);
var service = new AnswersService(db);
//Act
var expected = answer1.Id;
var result = await service.AddItemAsync(answer1);
//mock
// var result = await service.AddItemAsync(answer1);
//Assert
Assert.Equal(expected, result);
// result.Should().NotBeEmpty();
// result.Should().BeOfType(typeof(Answer));
// result.Should().BeSameAs(expected);
//Clean
await service.DeleteAsync(answer1);
}
public TriviaController()
{
this.db = new TriviaContext();
this.questionsService = new QuestionsService(db);
this.answersService = new AnswersService(db);
this.statisticsService = new StatisticsService(db);
}
async void OnAnswerButtonClicked(object sender, System.EventArgs e)
{
User user = JsonConvert.DeserializeObject <User>(Settings.UserSettings);
if (user != null)
{
if (answerEditor.Text == null || answerEditor.Text.Length == 0 ||
answerEditor.Text.Length > MAX_LENGTH)
{
return;
}
Answer newAnswer = new Answer()
{
Body = answerEditor.Text,
UserId = user.Id,
QuestionId = viewModel.QuestionViewModel.Question.Id
};
answerEditor.Text = null;
var answer = await AnswersService.DoAnswersAddRequest(newAnswer);
viewModel.LoadAnswersCommand.Execute(null);
}
else
{
await Navigation.PushModalAsync(new NavigationPage(new LoginPage()));
}
}
public void InvokeMapperMethodMapTo_WhenParametersAreCorrect()
{
//Arrange
var mapperMock = new Mock <IMappingProvider>();
var saverMock = new Mock <ISaver>();
var answerRepoMock = new Mock <IRepository <Answer> >();
var answerService = new AnswersService(saverMock.Object, mapperMock.Object, answerRepoMock.Object);
var data = new List <Answer>()
{
new Answer {
Id = 1, Content = "AlaBala", QuestionId = 1
}
};
answerRepoMock.Setup(a => a.All).Returns(data.AsQueryable());
var mapperData = new AnswerDto()
{
Id = 1, Content = "AlaBala", QuestionId = 1
};
mapperMock.Setup(m => m.MapTo <AnswerDto>(It.IsAny <Answer>())).Returns(mapperData);
//Act
var dto = answerService.GetById(1);
//Assert
mapperMock.Verify(x => x.MapTo <AnswerDto>(It.IsAny <Answer>()), Times.Once);
}
public void ReturnAnswerDto_WhenParametersAreCorrect()
{
//Arrange
var mapperMock = new Mock <IMappingProvider>();
var saverMock = new Mock <ISaver>();
var answerRepoMock = new Mock <IRepository <Answer> >();
var answerService = new AnswersService(saverMock.Object, mapperMock.Object, answerRepoMock.Object);
var data = new List <Answer>()
{
new Answer {
Id = 1, Content = "AlaBala", QuestionId = 1
}
};
answerRepoMock.Setup(a => a.All).Returns(data.AsQueryable());
var mapperData = new AnswerDto()
{
Id = 1, Content = "AlaBala", QuestionId = 1
};
mapperMock.Setup(m => m.MapTo <AnswerDto>(It.IsAny <Answer>())).Returns(mapperData);
//Act
var dto = answerService.GetById(1);
//Assert
Assert.IsNotNull(dto);
Assert.IsInstanceOfType(dto, typeof(AnswerDto));
}
public void TestGetAnswers_ReturnsNotNull()
{
var service = new AnswersService(new AnswersStubDao(), new EvaluationsStubDao(), new TemplatesStubDao());
var actual = service.GetAnswers(Guid.Parse("11111111-1111-1111-1111-111111111112"));
Assert.NotNull(actual);
}
public void AnswerExists(int answerId)
{
//Arrange
TestUtils testUtils = new TestUtils();
var db = testUtils.GetDbContext();
this.PopulateDb(db);
var sut = new AnswersService(db);
//Act
//Assert
Assert.True(sut.Exists(answerId));
}
public void CreateAnswerSavesItToDatabase(int questionId)
{
//Arrange
TestUtils testUtils = new TestUtils();
var db = testUtils.GetDbContext();
var sut = new AnswersService(db);
//Act
sut.Create(questionId, "asd", "test", DateTime.UtcNow);
//Assert
Assert.True(db.Answers.Any(a => a.QuestionId == questionId));
}
public void ThrowArgumentNullException_WhenInvokedWithNullAnswerRepositoryParameter()
{
//Arrange
var mapperMock = new Mock <IMappingProvider>();
var saverMock = new Mock <ISaver>();
var answerRepoMock = new Mock <IRepository <Answer> >();
//Act
var answerService = new AnswersService(saverMock.Object, mapperMock.Object, answerRepoMock.Object);
//Act & Assert
Assert.ThrowsException <ArgumentNullException>(() => new AnswersService(saverMock.Object, mapperMock.Object, null));
}
public async Task GetAllAnswersForAQuestionById_WithNonExistentQuestionId_ShouldReturnZeroCount()
{
string errorMessagePrefix = "AnswersService Method GetAllAnswersForAQuestionById() does not work properly.";
var context = CDGBulgariaInmemoryFactory.InitializeContext();
await SeedData(context);
this.answersService = new AnswersService(context);
List <AnswerServiceModel> actualResult = await this.answersService.GetAllAnswersForAQuestionById("fake1").ToListAsync();
Assert.True(actualResult.Count == 0, errorMessagePrefix);
}
private async Task <AnswersService> ArrangeServiceAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Answer>(db);
var questionRepository = new EfDeletableEntityRepository <Question>(db);
await this.AddQuestionAsync(questionRepository);
var service = new AnswersService(repository, questionRepository);
await service.CreateAsync("title", "content", this.stylist.Id, this.client.Id, this.question.Id);
return(service);
}
public void CreateInstance_WhenInvokedWithValidParameters()
{
//Arrange
var mapperMock = new Mock <IMappingProvider>();
var saverMock = new Mock <ISaver>();
var answerRepoMock = new Mock <IRepository <Answer> >();
//Act
var answerService = new AnswersService(saverMock.Object, mapperMock.Object, answerRepoMock.Object);
//Assert
Assert.IsNotNull(answerService);
Assert.IsInstanceOfType(answerService, typeof(IAnswersService));
}
public void DeleteAnswerRemovesItFromDb(int answerId)
{
//Arrange
TestUtils testUtils = new TestUtils();
var db = testUtils.GetDbContext();
this.PopulateDb(db);
var sut = new AnswersService(db);
//Act
sut.Delete(answerId);
//Assert
Assert.True(!db.Answers.Any(a => a.Id == answerId));
}
public void AnswerHasCorrectContent(int id)
{
//Arrange
TestUtils testUtils = new TestUtils();
var db = testUtils.GetDbContext();
this.PopulateDb(db);
var sut = new AnswersService(db);
//Act
var content = sut.GetAnswerContent(id);
//Assert
Assert.True(content == $"Content{id}");
}
public void ReturnTrueThatUserIfUserCanEdit(int id)
{
//Arrange
TestUtils testUtils = new TestUtils();
var db = testUtils.GetDbContext();
this.PopulateDb(db);
var sut = new AnswersService(db);
//Act
var canEdit = sut.UserCanEdit(id, $"asd{id}");
//Assert
Assert.True(canEdit);
}
public void UpdateAnswerContent(int id)
{
//Arrange
TestUtils testUtils = new TestUtils();
var db = testUtils.GetDbContext();
this.PopulateDb(db);
var sut = new AnswersService(db);
//Act
sut.Update(id, $"NewContent{id}");
//Assert
Assert.True(db.Answers.First(a => a.Id == id).Content == $"NewContent{id}");
}
public void GetAnswer_WhenAnswerDoesNotExist_ShouldThrowNotFoundException()
{
var returned = new TaskAnswer
{
Id = "id",
IsCorrect = true,
Location = "location",
Answer = "asnwer",
IsDeleted = false,
GameTaskId = "taskId"
};
taskAnswersRepositoryMock.Setup(s => s.Get("id")).Returns(returned);
var service = new AnswersService(mapper, taskAnswersRepositoryMock.Object);
Should.Throw <NotFoundException>(() => service.GetAnswer("Not existing"));
}
public async Task CheckGettingAnswersDetailsAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Answer>(db);
var questionRepository = new EfDeletableEntityRepository <Question>(db);
await this.AddQuestionAsync(questionRepository);
var service = new AnswersService(repository, questionRepository);
var answerId = await service.CreateAsync("title", "content", this.stylist.Id, this.client.Id, this.question.Id);
var answerResult = await service.GetAnswerDetailsAsync <TestAnswerModel>(answerId);
Assert.Equal(answerId, answerResult.Id);
}
public async Task AnswerIsRedAsyncPropertyShoudChangeToTrue()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Answer>(db);
var service = new AnswersService(repository, this.questionsRepository.Object);
var answer = new Answer()
{
Id = Guid.NewGuid().ToString()
};
await db.Answers.AddAsync(answer);
await db.SaveChangesAsync();
await service.ChangeIsRedAsync(answer.Id);
Assert.True(answer.IsRed);
}
public async Task Create_WithCorrectData_ShouldSuccesfullyCreate()
{
string errorMessagePrefix = "AnswersService Method CreateAnswer() does not work properly.";
var context = CDGBulgariaInmemoryFactory.InitializeContext();
await SeedData(context);
this.answersService = new AnswersService(context);
AnswerServiceModel answerServiceModel = new AnswerServiceModel()
{
Content = "Sofia is the place, where the association is founded.",
QuestionId = "dfghrf3456"
};
bool actualResult = await this.answersService.CreateAnswer(answerServiceModel);
Assert.True(actualResult, errorMessagePrefix);
}
protected async Task ExecuteLoadAnswersCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Answers.Clear();
var id = QuestionViewModel.Question.Id;
object responce = await AnswersService.DoAnswersGetRequest(id);
if (responce is ErrorMessage)
{
ErrorMessage error = responce as ErrorMessage;
Debug.WriteLine(error.ErrorCode + " " + error.ErrorDescription);
}
else
{
var answers = responce as IEnumerable <Answer>;
foreach (var answer in answers)
{
Answers.Add(new AnswerViewModel(answer));
}
}
OnPropertyChanged("IsExpanded");
//MessagingCenter.Send<AnswersViewModel>(this, "AnswersLoaded");
}
catch (Exception ex)
{
Debug.WriteLine("[!] ExecuteLoadAnswersCommand --- " + ex);
}
finally
{
IsBusy = false;
}
}
public void GetQuestionAnswers_WhenQuestionExists_ShouldReturnQuestionAnswers()
{
var answers = new List <TaskAnswer>()
{
new TaskAnswer
{
Id = "id1",
IsCorrect = true,
Location = "location 1",
Answer = "asnwer 1",
IsDeleted = false
},
new TaskAnswer
{
Id = "id2",
IsCorrect = false,
Location = "location 2",
Answer = "asnwer 2",
IsDeleted = false
}
};
taskAnswersRepositoryMock.Setup(s => s.GetAnswersByQuestion("questionId")).Returns(answers);
var service = new AnswersService(mapper, taskAnswersRepositoryMock.Object);
var results = service.GetQuestionAnswers("questionId");
results.ShouldNotBeNull();
results.Count().ShouldBe(answers.Count);
for (int i = 0; i < answers.Count; ++i)
{
var result = results.ToList()[i];
var expected = answers[i];
result.Answer.ShouldBe(expected.Answer);
result.Id.ShouldBe(expected.Id);
result.IsCorrect.ShouldBe(expected.IsCorrect);
result.Location.ShouldBe(expected.Location);
}
}
public void ThrowArgumentNullException_WhenAnswerDtoIsNull()
{
//Arrange
var mapperMock = new Mock <IMappingProvider>();
var saverMock = new Mock <ISaver>();
var answerRepoMock = new Mock <IRepository <Answer> >();
//Act
var answerService = new AnswersService(saverMock.Object, mapperMock.Object, answerRepoMock.Object);
var data = new List <Answer>()
{
new Answer {
Id = 1, Content = "AlaBala", QuestionId = 1
}
};
answerRepoMock.Setup(a => a.All).Returns(data.AsQueryable());
Assert.ThrowsException <ArgumentNullException>(() => answerService.GetById(1));
}
public void TestGetAnswerValueById()
{
var list = new List <Answer>()
{
new Answer()
{
Id = 1, Value = "1"
},
new Answer()
{
Id = 2, Value = "2"
},
new Answer()
{
Id = 3, Value = "3"
},
new Answer()
{
Id = 4, Value = "4"
},
new Answer()
{
Id = 5, Value = "5"
},
};
var mockRepo = new Mock <IDeletableEntityRepository <Answer> >();
mockRepo.Setup(x => x.AllAsNoTracking()).Returns(list.AsQueryable());
mockRepo.Setup(x => x.AddAsync(It.IsAny <Answer>())).Callback(
(Answer answer) => list.Add(answer));
var service = new AnswersService(mockRepo.Object);
var expected = "2";
var actual = service.GetAnswerValueById(2);
Assert.Equal(expected, actual);
}
public void GetAnswer_WhenAnswerExists_ShouldReturnAnswer()
{
var returned = new TaskAnswer
{
Id = "id",
IsCorrect = true,
Location = "location",
Answer = "asnwer",
IsDeleted = false,
GameTaskId = "taskId"
};
taskAnswersRepositoryMock.Setup(s => s.Get("id")).Returns(returned);
var service = new AnswersService(mapper, taskAnswersRepositoryMock.Object);
var result = service.GetAnswer("id");
result.Answer.ShouldBe(returned.Answer);
result.Id.ShouldBe(returned.Id);
result.IsCorrect.ShouldBe(returned.IsCorrect);
result.Location.ShouldBe(returned.Location);
}
public AnswersController(AnswersService service)
{
_service = service;
}
public void TestGetQuestionAnswersForTakesById()
{
var listQuestionAnswer1 = new List <QuestionAnswer>()
{
new QuestionAnswer()
{
AnswerId = 1, QuestionId = 2
},
};
var listQuestionAnswer2 = new List <QuestionAnswer>()
{
new QuestionAnswer()
{
AnswerId = 2, QuestionId = 1
},
};
var listQuestionAnswer3 = new List <QuestionAnswer>()
{
new QuestionAnswer()
{
AnswerId = 4, QuestionId = 2
},
};
var list = new List <Answer>()
{
new Answer()
{
Id = 1, Value = "1", Questions = listQuestionAnswer1
},
new Answer()
{
Id = 2, Value = "2", Questions = listQuestionAnswer2
},
new Answer()
{
Id = 3, Value = "3", Questions = listQuestionAnswer3
},
new Answer()
{
Id = 4, Value = "4", Questions = listQuestionAnswer2
},
};
var listQuestions = new List <Question>()
{
new Question()
{
Id = 1
},
new Question()
{
Id = 2
},
};
var mockRepo = new Mock <IDeletableEntityRepository <Answer> >();
mockRepo.Setup(x => x.AllAsNoTracking()).Returns(list.AsQueryable());
mockRepo.Setup(x => x.AddAsync(It.IsAny <Answer>())).Callback(
(Answer answer) => list.Add(answer));
var service = new AnswersService(mockRepo.Object);
var expected = new List <AnswerViewModel>()
{
new AnswerViewModel()
{
Id = 1, Value = "1"
},
new AnswerViewModel()
{
Id = 4, Value = "4"
},
};
var actual = service.GetQuestionAnswersForTakesById(2);
Assert.Equal(string.Join(" ", expected), string.Join(" ", actual));
}
public void TestGetGetQuestionAnswerById()
{
var listQuestionAnswer1 = new List <QuestionAnswer>()
{
new QuestionAnswer()
{
AnswerId = 1, QuestionId = 1
},
};
var listQuestionAnswer2 = new List <QuestionAnswer>()
{
new QuestionAnswer()
{
AnswerId = 2, QuestionId = 1
},
};
var list = new List <Answer>()
{
new Answer()
{
Id = 1, Value = "1", Questions = listQuestionAnswer1
},
new Answer()
{
Id = 2, Value = "2", Questions = listQuestionAnswer2
},
new Answer()
{
Id = 3, Value = "3"
},
new Answer()
{
Id = 4, Value = "4"
},
new Answer()
{
Id = 5, Value = "5"
},
};
var listQuestions = new List <Question>()
{
new Question()
{
Id = 1
},
new Question()
{
Id = 2
},
};
var mockRepo = new Mock <IDeletableEntityRepository <Answer> >();
mockRepo.Setup(x => x.AllAsNoTracking()).Returns(list.AsQueryable());
mockRepo.Setup(x => x.AddAsync(It.IsAny <Answer>())).Callback(
(Answer answer) => list.Add(answer));
var service = new AnswersService(mockRepo.Object);
var expected = new List <AnswerInTestModel>()
{
new AnswerInTestModel()
{
Id = 1, Value = "1"
},
new AnswerInTestModel()
{
Id = 2, Value = "2"
},
};
AutoMapperConfig.RegisterMappings(typeof(AnswerInTestModel).GetTypeInfo().Assembly);
var actual = service.GetQuestionAnswersById <AnswerInTestModel>(1);
Assert.Equal(string.Join(" ", expected), string.Join(" ", actual));
}
