public override void OnInspectorGUI()
{
serializedObject.Update();
AnswerBuilder answerBuilder = target as AnswerBuilder;
GUILayout.Label("THEME INFOR", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(serializedObject.FindProperty("nameTheme"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("idTheme"));
GUILayout.Space(10);
GUILayout.Label("LEVEL INFOR", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(serializedObject.FindProperty("idLevel"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("size"));
GUILayout.Space(5);
EditorGUILayout.PropertyField(serializedObject.FindProperty("listTexture"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("listSample"));
GUILayout.Space(10);
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Spawn Piece"))
{
answerBuilder.Intial();
}
if (GUILayout.Button("Check"))
{
answerBuilder.CheckAnswer();
}
GUILayout.EndHorizontal();
if (GUILayout.Button("Clear"))
{
answerBuilder.Clear();
}
GUILayout.EndVertical();
GUILayout.Space(20);
GUILayout.Label("JSON", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(serializedObject.FindProperty("nameAnswerFile"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("listAnswerForSample"));
GUILayout.BeginVertical();
//GUILayout.BeginHorizontal();
if (GUILayout.Button("Create"))
{
answerBuilder.CreateJson(false);
}
if (GUILayout.Button("Update"))
{
answerBuilder.CreateJson(true);
}
//GUILayout.EndHorizontal();
GUILayout.EndVertical();
serializedObject.ApplyModifiedProperties();
}
public void AnswerIsCorrectShouldGetAndSetValues()
{
// Arrange
var answer = new AnswerBuilder().Build();
// Act
answer.IsCorrectAnswer = true;
var actual = answer.IsCorrectAnswer;
// Assert
Assert.AreEqual(true, actual);
}
public void Answer_EditingWithInvalidData_FailsValidation(string userId, string body)
{
// Arrange - Build Answer
var question = new QuestionBuilder().SetupValidQuestion().Build();
var target = new AnswerBuilder().SetupValidAnswer(question).Build();
var limits = new LimitsBuilder().Build();
var user = new UserBuilder().BuildUser(new Guid(userId)).Build();
// Act, Assert
Assert.Throws <BusinessException>(() =>
target.Edit(user, body, limits));
}
public void Question_CannotBeAnsweredBySameUserMoreThanOnce_Throws()
{
// Arrange
var target = new QuestionBuilder().SetupValidQuestion().Build();
var firstAnswer = new AnswerBuilder().SetupValidAnswer(target, new Guid("00000000-0000-0000-0000-000000000001")).Build();
var secondAnswer = new AnswerBuilder().SetupValidAnswer(target, new Guid("00000000-0000-0000-0000-000000000001")).Build();
target.Answer(firstAnswer);
// Act, Assert
Assert.Throws <BusinessException>(() => target.Answer(secondAnswer));
}
public void Question_NonExistingAnswerCannotBeAccepted_Throws()
{
// Arrange
var limits = new LimitsBuilder().Build();
var target = new QuestionBuilder().SetupValidQuestion().Build();
var firstAnswer = new AnswerBuilder().SetupValidAnswer(target).Build();
var secondAnswer = new AnswerBuilder().SetupAnotherValidAnswer(target).Build();
target.Answer(firstAnswer);
// Act, Assert
Assert.Throws <BusinessException>(() => target.AcceptAnswer(secondAnswer));
}
public void AnswerWeightShouldGetAndSetValues()
{
// Arrange
var answer = new AnswerBuilder().Build();
var expected = 5;
// Act
answer.Weight = expected;
var actual = answer.Weight;
// Assert
Assert.AreEqual(expected, actual);
}
public void AnswerTextShouldGetAndSetValues()
{
// Arrange
var answer = new AnswerBuilder().Build();
var expected = "Test Answer";
// Act
answer.Text = expected;
var actual = answer.Text;
// Assert
Assert.AreEqual(expected, actual);
}
public void Question_MoreThanOneAcceptedAnswer_Throws()
{
// Arrange
var target = new QuestionBuilder().SetupValidQuestion().Build();
var firstAnswer = new AnswerBuilder().SetupValidAnswer(target).Build();
var secondAnswer = new AnswerBuilder().SetupAnotherValidAnswer(target).Build();
target.Answer(firstAnswer);
target.Answer(secondAnswer);
target.AcceptAnswer(firstAnswer);
// Act, Assert
Assert.Throws <BusinessException>(() => target.AcceptAnswer(secondAnswer));
}
public void Voteable_CanApplyVoteToAnswer_Successfully()
{
// Arrange
var question = new QuestionBuilder().SetupValidQuestion().Build();
var target = new AnswerBuilder().SetupValidAnswer(question).Build();
var vote = new VoteBuilder(target).SetupValidUpvote().ByOneUser().Build();
// Act
target.ApplyVote(vote);
// Assert
Assert.Equal(1, target.VotesSum);
Assert.Contains(vote, target.Votes);
}
public void Question_OnAnswered_SetHasAcceptedAnswer()
{
// Arrange
var target = new QuestionBuilder().SetupValidQuestion().Build();
var answer = new AnswerBuilder().SetupValidAnswer(target).Build();
target.Answer(answer);
// Act
target.AcceptAnswer(answer);
// Assert
Assert.True(target.HasAcceptedAnswer);
}
public void Question_CanBeAnsweredBySameUserOnlyOnce_Sucessfully()
{
// Arrange
var target = new QuestionBuilder().SetupValidQuestion().Build();
var firstAnswer = new AnswerBuilder().SetupValidAnswer(target).Build();
var secondAnswer = new AnswerBuilder().SetupAnotherValidAnswer(target).Build();
// Act
target.Answer(firstAnswer);
target.Answer(secondAnswer);
// Assert
Assert.Equal(2, target.Answers.Count());
Assert.Contains(firstAnswer, target.Answers);
Assert.Contains(secondAnswer, target.Answers);
}
public async Task WriteService_CreateQuizWithQuestionsAndAnswersAndCorrectAnswer_CreatedSucessfully()
{
using var dbTrans = await NoCommitFactory().Create();
var service = GetQuizReadService(dbTrans);
var writeService = GetQuizWriteService(dbTrans);
var questionBuilder1 = QuestionBuilder.New().WithText("Question 1").WithAnswers(new List <Answer>
{
AnswerBuilder.New().WithText("Q1: Answer 1").Entity,
AnswerBuilder.New().WithText("Q1: Answer 2").Entity,
AnswerBuilder.New().WithText("Q1: Answer 3").Entity
});
var questionBuilder2 = QuestionBuilder.New().WithText("Question 2").WithAnswers(new List <Answer>
{
AnswerBuilder.New().WithText("Q2: Answer 1").Entity,
AnswerBuilder.New().WithText("Q2: Answer 2").Entity,
AnswerBuilder.New().WithText("Q2: Answer 3").Entity
});
var quizBuilder = QuizBuilder.New().WithTitle("Test Quiz").WithQuestions(new List <Question> {
questionBuilder1.Entity, questionBuilder2.Entity
});
await writeService.CreateQuiz(quizBuilder.Entity);
var quiz = Assert.Single(await service.GetAllQuiz());
Assert.NotNull(quiz);
Assert.InRange(quiz.Questions.ToList().Count, 2, 2);
foreach (var question in quiz.Questions)
{
Assert.Null(question.CorrectAnswer);
Assert.InRange(question.AvailableAnswers.Count(), 3, 3);
}
quiz = await service.GetQuizById(quiz.Id);
Assert.NotNull(quiz);
var q = quiz.Questions.First();
q.CorrectAnswer = q.AvailableAnswers.First();
await writeService.UpdateQuestion(q);
Assert.Single(quiz.Questions.Where(a => a.CorrectAnswer != null).ToList());
}
public void AddAnswerToQuestionShouldWork()
{
// Arrange
var expectedAnswerTitle = "Test Answer";
var expectedCount = 1;
var question = new QuestionBuilder().Build();
var answer = new AnswerBuilder().WithText(expectedAnswerTitle).Build();
// Act
question.Answers.Add(answer);
var actualCount = question.Answers.Count();
var actualAnswer = question.Answers.FirstOrDefault();
// Assert
Assert.AreEqual(expectedCount, actualCount);
Assert.AreSame(answer, actualAnswer);
}
public void Question_UndoAcceptedAnswerOutsideDeadline_Throws()
{
// Arrange
var limits = new LimitsBuilder().Build();
var target = new QuestionBuilder().SetupValidQuestion().Build();
var answer = new AnswerBuilder().SetupValidAnswer(target).Build();
target.Answer(answer);
target.AcceptAnswer(answer);
// 1 minute past deadline
answer.SetProperty(
nameof(answer.AcceptedOn),
DateTime.UtcNow.AddMinutes(-1 - limits.AcceptAnswerDeadline.Minutes));
// Act, Assert
Assert.Throws <BusinessException>(() => target.UndoAcceptAnswer(answer, limits));
}
public void Answer_EditingOutsideDeadline_Fails()
{
// Arrange - Build Answer, 1 minute after deadline.
var limits = new LimitsBuilder().Build();
var question = new QuestionBuilder().SetupValidQuestion().Build();
var target = new AnswerBuilder()
.SetupValidAnswer(question)
.MakeTimeGoBy()
.Build();
// Arrange - Edit Data
string editedBody = "BodyNormal";
// Act
Assert.Throws <BusinessException>(() =>
target.Edit(target.User, editedBody, limits));
}
public void Question_UndoAcceptedAnswerWithinDeadline_Successfully()
{
// Arrange
var limits = new LimitsBuilder().Build();
var target = new QuestionBuilder().SetupValidQuestion().Build();
var answer = new AnswerBuilder().SetupValidAnswer(target).Build();
target.Answer(answer);
target.AcceptAnswer(answer);
// Act
target.UndoAcceptAnswer(answer, limits);
// Assert
Assert.False(target.HasAcceptedAnswer);
Assert.False(answer.IsAcceptedAnswer);
Assert.Null(answer.AcceptedOn);
}
/// <summary>
/// Executes the "Calc" command, which is the main command of the app.
/// It converts ValueCurrency to DisplayCurrencies and prints the results out.
/// </summary>
/// <param name="message">the message a user sent</param>
/// <param name="client">Bot instance, needed to answer on the message</param>
/// <param name="repo">Repository for the whole db, allows this command handler to save/read data</param>
/// <returns>Task to be awaited</returns>
public override async Task Execute(Message message)
{
var messageText = message?.Text;
if (messageText == null)
{
return;
}
var content = messageText
.TrimStart(charsToIgnore) // "/calc" <- remove that if exists
.Replace(',', '.'); // can process both , and . in the number
if (!decimal.TryParse(content, out var value))
{
throw new Exception("Problems occured when parsing your message");
}
var messageId = message.MessageId;
var chatId = message.Chat.Id;
var dataTask = CurrenciesDataCaching.GetValCursAsync();
await Repo.EnsureChatCreatedAsync(chatId); // ensure chat is created, so that it is not added multiple times (in multiple threads)
// execute them all in parallel and wait for the completion
var percentsTask = Repo.GetPercentsAsync(chatId);
var valueCurrencyTask = Repo.GetCurrencyEmojiAsync(chatId);
var displayCurrenciesTask = Repo.GetDisplayCurrenciesEmojisAsync(chatId);
await Task.WhenAll(dataTask, percentsTask, valueCurrencyTask, displayCurrenciesTask);
var values =
await ValuesCalculator.GetCurrenciesValuesAsync(
value,
valueCurrencyTask.Result,
dataTask.Result,
displayCurrenciesTask.Result);
var textToSend = await AnswerBuilder.BuildStringFromValuesAsync(
values, valueCurrencyTask.Result, percentsTask.Result);
await Client.SendTextMessageAsync(chatId, textToSend, replyToMessageId : messageId);
}
public void Answer_AcceptedAnswer_Successfully()
{
// Arrange
var question = new QuestionBuilder().SetupValidQuestion().Build();
var target = new AnswerBuilder().SetupValidAnswer(question).Build();
var originalId = target.Id;
var originalUserId = target.UserId;
var originalBody = target.Body;
var originalCreatedOn = target.CreatedOn;
var originalQuestion = target.Question;
// Act
target.AcceptedAnswer();
// Assert
Assert.Equal(originalId, target.Id);
Assert.Equal(originalUserId, target.UserId);
Assert.Equal(originalBody, target.Body);
Assert.Equal(originalCreatedOn, target.CreatedOn);
Assert.True(target.IsAcceptedAnswer);
Assert.True(DateTime.UtcNow - target.AcceptedOn < TimeSpan.FromSeconds(1));
}
public void Answer_UndoAcceptedAnswer_Successfully()
{
// Arrange
var question = new QuestionBuilder().SetupValidQuestion().Build();
var target = new AnswerBuilder().SetupValidAnswer(question).Build();
var originalId = target.Id;
var originalUserId = target.UserId;
var originalBody = target.Body;
var originalCreatedOn = target.CreatedOn;
var originalQuestion = target.Question;
// Act
target.AcceptedAnswer();
target.UndoAcceptedAnswer();
// Assert
Assert.Equal(originalId, target.Id);
Assert.Equal(originalUserId, target.UserId);
Assert.Equal(originalBody, target.Body);
Assert.Equal(originalCreatedOn, target.CreatedOn);
Assert.False(target.IsAcceptedAnswer);
Assert.Null(target.AcceptedOn);
}
public void Answer_EditingWithValidDataWithinDeadline_Successfully()
{
// Arrange - Build Question
var question = new QuestionBuilder().SetupValidQuestion().Build();
var target = new AnswerBuilder()
.SetupValidAnswer(question)
.Build();
var userId = target.UserId;
// Arrange - Edit Data
string editedBody = "BodyNormal";
var limits = new LimitsBuilder().Build();
// Act
target.Edit(target.User, editedBody, limits);
var result = target;
// Assert
Assert.NotEqual(default(Guid), result.Id);
Assert.Equal(userId, result.UserId);
Assert.Equal(editedBody, result.Body);
Assert.Empty(result.Comments);
}
public async Task HandleAsync(InlineQuery q)
{
if (IsNullOrEmpty(q.Query))
{
return;
}
var input = q.Query;
var dataTask = GetValCursAsync();
var currenciesEmojisTask = repo.GetCurrencyEmojisAsync();
var data = dataTask.Result;
var currenciesEmojis = currenciesEmojisTask.Result;
string currency = null;
foreach (var i in currenciesEmojis)
{
if (input.Contains(i.Currency))
{
currency = i.Currency;
break;
}
}
var space = " "; // format: {decimal}{space}{currency} e.g "53.2 UAH" or just {decimal}
var argsPart = currency == null ? "" : $"{space}{currency}";
var pattern = $@"[0-9][0-9]*([\.,][0-9][0-9]*)?{argsPart}";
if (!Regex.IsMatch(input, pattern))
{
var text = "format: {decimal}{space}{currency} e.g \"53.2 UAH\" or just {decimal} e.g \"53.2\"";
await bot.AnswerInlineQueryAsync(
q.Id,
await InlineAnswerBuilder.ArticleToQueryResultAsync(
"Result", text, text)
);
return;
}
var valueToParse = IsNullOrEmpty(argsPart) ? input : input.Replace(argsPart, "");
var isValid = decimal.TryParse(valueToParse, out var value);
if (isValid)
{
if (currency == null)
{
currency = DefaultValues.DefaultValueCurrency;
}
var currencyEmoji = currenciesEmojis.First(ce => ce.Currency == currency);
var values =
await ValuesCalculator.GetCurrenciesValuesAsync(value, currencyEmoji, data, currenciesEmojis);
var answer1 = await AnswerBuilder.BuildStringFromValuesAsync(values, currencyEmoji);
await bot.AnswerInlineQueryAsync(
q.Id,
await InlineAnswerBuilder.ArticleToQueryResultAsync(
"Result", answer1, answer1)
);
}
}
public async Task WriteService_CreateQuizResponse_CreatedSucessfully()
{
using var dbTrans = await NoCommitFactory().Create();
var service = GetQuizReadService(dbTrans);
var writeService = GetQuizWriteService(dbTrans);
var questionBuilder1 = QuestionBuilder.New().WithText("Question 1").WithAnswers(new List <Answer>
{
AnswerBuilder.New().WithText("Q1: Answer 1").Entity,
AnswerBuilder.New().WithText("Q1: Answer 2").Entity,
AnswerBuilder.New().WithText("Q1: Answer 3").Entity
});
var questionBuilder2 = QuestionBuilder.New().WithText("Question 2").WithAnswers(new List <Answer>
{
AnswerBuilder.New().WithText("Q2: Answer 1").Entity,
AnswerBuilder.New().WithText("Q2: Answer 2").Entity,
AnswerBuilder.New().WithText("Q2: Answer 3").Entity
});
var quizBuilder = QuizBuilder.New().WithTitle("Test Quiz").WithQuestions(new List <Question> {
questionBuilder1.Entity, questionBuilder2.Entity
});
await writeService.CreateQuiz(quizBuilder.Entity);
var quiz = Assert.Single(await service.GetAllQuiz());
Assert.NotNull(quiz);
Assert.InRange(quiz.Questions.ToList().Count, 2, 2);
foreach (var question in quiz.Questions)
{
Assert.Null(question.CorrectAnswer);
Assert.InRange(question.AvailableAnswers.Count(), 3, 3);
}
quiz = await service.GetQuizById(quiz.Id);
Assert.NotNull(quiz);
var q = quiz.Questions.First();
q.CorrectAnswer = q.AvailableAnswers.First();
await writeService.UpdateQuestion(q);
Assert.Single(quiz.Questions.Where(a => a.CorrectAnswer != null).ToList());
var q2 = quiz.Questions.Last();
q2.CorrectAnswer = q2.AvailableAnswers.Last();
await writeService.UpdateQuestion(q2);
quiz = await service.GetQuizById(quiz.Id);
Assert.InRange(quiz.Questions.Where(a => a.CorrectAnswer != null).ToList().Count, 2, 2);
// Quiz is ready now
await writeService.CreateQuizResponse(new QuizResponse
{
Quiz = quiz, Question = quiz.Questions.First(), GivenAnswer = quiz.Questions.First().AvailableAnswers.Last() // wrong answer
});
await writeService.CreateQuizResponse(new QuizResponse
{
Quiz = quiz, Question = quiz.Questions.Last(), GivenAnswer = quiz.Questions.Last().AvailableAnswers.Last() // correct answer
});
var response = await service.GetQuizResponse(quiz.Id);
Assert.NotEmpty(response);
Assert.InRange(response.Count(), 2, 2);
Assert.Equal(1, response.Sum(s => s.AnswerPoint));
}
public async Task WriteService_DeleteAnswer_DeleteSucessfully()
{
using var dbTrans = await NoCommitFactory().Create();
var service = GetQuizReadService(dbTrans);
var writeService = GetQuizWriteService(dbTrans);
await writeService.CreateQuiz(QuizBuilder.New().WithTitle("Test Quiz")
.WithQuestion(QuestionBuilder.New().WithText("Question 1").WithAnswer(AnswerBuilder.New().WithText("Test Answer 1").Entity)
.Entity).Entity);
var quiz = Assert.Single(await service.GetAllQuiz());
Assert.NotNull(quiz);
Assert.NotEmpty(quiz.Questions);
var question = quiz.Questions.First();
await writeService.DeleteAnswer(question.AvailableAnswers.First().Id);
quiz = await service.GetQuizById(quiz.Id);
Assert.NotNull(quiz);
Assert.NotEmpty(quiz.Questions);
Assert.Null(quiz.Questions.First().AvailableAnswers);
}
public void RemoveInexistentAnswerShouldFail()
{
// Arrange
var falseAnswer = new AnswerBuilder().Build();
var answer = new AnswerBuilder().Build();
var question = new QuestionBuilder().WithAnswer(answer).Build();
// Act
var actual = question.Answers.Remove(falseAnswer);
// Assert
Assert.IsFalse(actual);
}
public void RemoveAnswerToQuestionShouldWork()
{
// Arrange
var expectedCount = 0;
var answer = new AnswerBuilder().Build();
var question = new QuestionBuilder().WithAnswer(answer).Build();
// Act
question.Answers.Remove(answer);
var actualCount = question.Answers.Count();
var actualAnswer = question.Answers.FirstOrDefault();
// Assert
Assert.AreEqual(expectedCount, actualCount);
Assert.AreSame(null, actualAnswer);
}
