public void TearDown()
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
List <TestResult> testTestResults = context.TestResults.ToList();
foreach (var testResult in testTestResults)
{
context.TestResults.Remove(testResult);
}
List <QuestionOption> testQuestionOptions = context.QuestionOptions.ToList();
foreach (var questionOption in testQuestionOptions)
{
context.QuestionOptions.Remove(questionOption);
}
List <Question> testQuestions = context.Questions.ToList();
foreach (var question in testQuestions)
{
context.Questions.Remove(question);
}
List <Test> testTests = context.Tests.ToList();
foreach (var test in testTests)
{
context.Tests.Remove(test);
}
List <TestSeries> testTestSeries = context.TestSeries.ToList();
foreach (var testSeries in testTestSeries)
{
context.TestSeries.Remove(testSeries);
}
List <SubTopic> testSubTopics = context.SubTopics.ToList();
foreach (var subTopic in testSubTopics)
{
context.SubTopics.Remove(subTopic);
}
List <MainTopic> testMainTopics = context.MainTopics.ToList();
foreach (var mainTopic in testMainTopics)
{
context.MainTopics.Remove(mainTopic);
}
List <Account> testAccounts = context.Accounts.Where(a => a.User.Username != "test1").ToList();
foreach (var account in testAccounts)
{
context.Accounts.Remove(account);
}
List <User> testUsers = context.Users.Where(a => a.Username != "test1").ToList();
foreach (var user in testUsers)
{
context.Users.Remove(user);
}
context.SaveChanges();
}
}
private void FuncToCall6(object context)
{
if (CreatedMainTopicTitle == null || CreatedSubTopicTitle == "")
{
MessageBox.Show("You must enter a valid name in order to delete a main topic.");
}
else
{
using (SelfAssessmentDbContext db = new SelfAssessmentDbContext())
{
List <SubTopic> subTopics = db.SubTopics
.Include(s => s.MainTopic)
.Where(m => m.MainTopic.Title == SelectedMainTopic.Title)
.ToList();
foreach (SubTopic subTopic in subTopics)
{
db.SubTopics.Remove(subTopic);
}
MainTopic mainTopic = db.MainTopics.Where(m => m.Title == SelectedMainTopic.Title).FirstOrDefault();
db.Set <MainTopic>().Remove(mainTopic);
db.SaveChanges();
}
SelectedMainTopic = null;
MainTopics = Context.MainTopics.ToList();
CreatedMainTopicTitle = null;
SubTopics = null;
}
}
public async Task <Question> CreateNewQuestion(Question question, string testName, string option1, string option2, string option3, string option4)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
question.Test = context.Tests.Where(q => q.TestName == testName)
.FirstOrDefault();
EntityEntry <Question> createdResult = await context.Set <Question>().AddAsync(question);
await context.Set <QuestionOption>().AddAsync(new QuestionOption {
OptionText = option1, Question = question
});
await context.Set <QuestionOption>().AddAsync(new QuestionOption {
OptionText = option2, Question = question
});
await context.Set <QuestionOption>().AddAsync(new QuestionOption {
OptionText = option3, Question = question
});
await context.Set <QuestionOption>().AddAsync(new QuestionOption {
OptionText = option4, Question = question
});
await context.SaveChangesAsync();
return(createdResult.Entity);
}
}
private void FuncToCall4(object context)
{
if (CreatedMainTopicTitle == null || CreatedSubTopicTitle == "")
{
MessageBox.Show("You must enter a name in order to create a main topic.");
}
else
{
using (SelfAssessmentDbContext db = new SelfAssessmentDbContext())
{
MainTopic checkMainTopic = db.MainTopics.Where(m => m.Title == CreatedMainTopicTitle).FirstOrDefault();
if (checkMainTopic == null)
{
db.MainTopics.Add(new MainTopic()
{
Title = CreatedMainTopicTitle
});
db.SaveChanges();
}
else
{
MessageBox.Show("This main topic already exists!");
}
}
MainTopics = Context.MainTopics.ToList();
CreatedMainTopicTitle = null;
}
}
public async Task CreateNewQuestion_GivenQuestionTextAndAllQuestionOptions()
{
Question newQuestion = new Question()
{
QuestionText = "TestQuestion1",
CorrectAnswer = "Option2",
QuestionMark = 10,
};
await questionService.CreateNewQuestion(newQuestion, "Test1", "Option1", "Option2", "Option3", "Option4");
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
Question createdQuestion = context.Questions
.Include(q => q.QuestionOptions)
.Where(q => q.QuestionText == "TestQuestion1")
.FirstOrDefault();
Assert.AreEqual("TestQuestion1", createdQuestion.QuestionText);
Assert.AreEqual("Option1", createdQuestion.QuestionOptions.ToList()[0].OptionText);
Assert.AreEqual("Option2", createdQuestion.QuestionOptions.ToList()[1].OptionText);
Assert.AreEqual("Option3", createdQuestion.QuestionOptions.ToList()[2].OptionText);
Assert.AreEqual("Option4", createdQuestion.QuestionOptions.ToList()[3].OptionText);
Assert.AreEqual("Option2", createdQuestion.CorrectAnswer);
}
}
public async Task <IEnumerable <Question> > GetAllQuestionsForGivenTestName(string testName)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
return(await context.Questions.Include(q => q.Test).Where(t => t.Test.TestName == testName).ToListAsync());
}
}
public async Task <TestResult> CreatePersonalTestResult(int id, string testName, TestResult testResult)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
TestResult testResultCheck = context.TestResults.Where(t => t.Test.TestName == testName).FirstOrDefault(); //return already existing test result for that test
if (testResultCheck == null)
{
Account account = context.Accounts.Where(a => a.Id == id).FirstOrDefault();
Test test = context.Tests.Where(e => e.TestName == testName).FirstOrDefault();
testResult.Account = account;
testResult.Test = test;
EntityEntry <TestResult> createdResult = await context.Set <TestResult>().AddAsync(testResult);
await context.SaveChangesAsync();
return(createdResult.Entity);
}
else
{
if (testResultCheck.Mark < testResult.Mark) //if user scores a higher mark
{
testResultCheck.Mark = testResult.Mark;
context.Set <TestResult>().Update(testResultCheck);
await context.SaveChangesAsync();
}
return(testResultCheck);
}
}
}
public async Task ReadFunctionalityRetrievesQuestionOptionAndCorrespondingQuestionAndTest()
{
Test test;
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
test = new Test()
{
TestName = "Test1"
};
Question question = new Question {
Test = test, QuestionText = "TestQuestion1"
};
QuestionOption questionOption = new QuestionOption()
{
OptionText = "TestOption1", Question = question
};
await context.Set <Test>().AddAsync(test);
await context.Set <Question>().AddAsync(question);
await context.Set <QuestionOption>().AddAsync(questionOption);
await context.SaveChangesAsync();
}
Test retrievedTest = await testService.Get(test.Id);
Question retrievedQuestion = retrievedTest.Questions.ToList()[0];
QuestionOption retrievedQuestionOption = retrievedQuestion.QuestionOptions.ToList()[0];
Assert.AreEqual("Test1", retrievedTest.TestName);
Assert.AreEqual("TestQuestion1", retrievedQuestion.QuestionText);
Assert.AreEqual("TestOption1", retrievedQuestionOption.OptionText);
}
public async Task CreatedAccountsAreDeletedWhenDeleteOperationCalled()
{
User user = new User()
{
Username = "******",
PasswordHashed = "test3",
Email = "*****@*****.**",
DateJoined = DateTime.Now
};
Account account = new Account()
{
User = user,
};
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
await context.Set <Account>().AddAsync(account);
await context.SaveChangesAsync();
await accountService.Delete(account.Id);
Account retrievedAccount = context.Accounts.Where(a => a.User.Username == "test3").FirstOrDefault();
Assert.IsNull(retrievedAccount);
}
}
private void FuncToCall3(object context)
{
if (SelectedSubTopic == null)
{
MessageBox.Show("You must select a sub-topic to delete");
}
else
{
using (SelfAssessmentDbContext newContext = new SelfAssessmentDbContext())
{
SubTopic retrievedSubTopic = newContext.SubTopics.Where(st => st.Id == SelectedSubTopic.Id).FirstOrDefault();
newContext.SubTopics.Remove(retrievedSubTopic);
newContext.SaveChanges();
}
SubTopics = Context.SubTopics.Include(m => m.MainTopic)
.Where(r => r.MainTopic.Id == SelectedMainTopic.Id)
.ToList();
SelectedSubTopic = null;
TopicIntroduction = null;
TopicContent = null;
TopicSummary = null;
CreatedSubTopicTitle = null;
CreatedSubTopicIntro = null;
CreatedSubTopicContent = null;
CreatedSubTopicSummary = null;
}
}
public async Task ACreatedAccountHasUserAndAccountSavedToDatabase()
{
User user = new User()
{
Username = "******",
PasswordHashed = "test3",
Email = "*****@*****.**",
DateJoined = DateTime.Now
};
Account account = new Account()
{
User = user,
};
await accountService.Create(account);
Account retrievedAccount;
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
retrievedAccount = context.Accounts.Include(u => u.User).Where(a => a.User.Username == "test3").FirstOrDefault();
}
Assert.AreEqual("test3", retrievedAccount.User.Username);
Assert.AreEqual("test3", retrievedAccount.User.PasswordHashed);
Assert.AreEqual("*****@*****.**", retrievedAccount.User.Email);
}
public async Task <Account> GetByUsername(string username)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
return(await context.Accounts
.Include(a => a.User)
.FirstOrDefaultAsync(a => a.User.Username == username));
}
}
public virtual async Task <T> Get(int id)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
T entity = await context.Set <T>().FirstOrDefaultAsync((e) => e.Id == id);
return(entity);
}
}
public virtual async Task <IEnumerable <T> > GetAll()
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
IEnumerable <T> entities = await context.Set <T>()
.ToListAsync();
return(entities);
}
}
public virtual async Task <IEnumerable <T> > GetByParameter(IdentityObject parameter)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
IEnumerable <T> entities = await context.Set <T>().Where(t => t.Id == parameter.Id)
.ToListAsync();
return(entities);
}
}
public async Task GetAllPersonalTestResults()
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
Account account = context.Accounts.Where(a => a.User.Username == "test2").FirstOrDefault();
List <TestResult> testResults = await testResultService.GetPersonalTestResults(account, "TestTestSeries");
Assert.AreEqual(1, testResults.Count);
}
}
public async Task ReadFunctionalityRetrievesAccountAndUserDataFromDatabase_WhenRetrievingByID()
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
Account getAccountId = context.Accounts.Where(a => a.User.Username == "test2").FirstOrDefault();
Account retrievedAccount = await accountService.Get(getAccountId.Id);
Assert.AreEqual("test2", retrievedAccount.User.Username);
Assert.AreEqual("*****@*****.**", retrievedAccount.User.Email);
}
}
public virtual async Task <T> Update(int id, T entity)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
entity.Id = id;
context.Set <T>().Update(entity);
await context.SaveChangesAsync();
return(entity);
}
}
public override async Task <Account> Get(int id)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
Account entity = await context.Accounts
.Include(a => a.User)
.FirstOrDefaultAsync((e) => e.Id == id);
return(entity);
}
}
public override async Task <IEnumerable <Account> > GetAll()
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
IEnumerable <Account> entities = await context.Accounts
.Include(a => a.User)
.ToListAsync();
return(entities);
}
}
public virtual async Task <T> Create(T entity)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
EntityEntry <T> createdResult = await context.Set <T>().AddAsync(entity);
await context.SaveChangesAsync();
return(createdResult.Entity);
}
}
public async Task CreateANewSubTopicGivenAllNecessaryParameters()
{
await subTopicService.CreateNewSubTopic("MainTopic", "Title", "Intro", "Content", "Summary");
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
SubTopic subTopic = context.SubTopics.Where(s => s.Title == "Title").FirstOrDefault();
Assert.AreEqual("Title", subTopic.Title);
Assert.AreEqual("Intro", subTopic.Introduction);
}
}
public async Task DeleteTestAndAssociatedQuestions()
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
Test createdTest = context.Tests
.Where(t => t.TestName == "TestName")
.FirstOrDefault();
bool result = await testService.Delete(createdTest.Id);
Assert.IsTrue(result);
}
}
public override async Task <Test> Get(int id)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
Test entity = await context.Set <Test>()
.Include(t => t.Questions)
.ThenInclude(q => q.QuestionOptions)
.FirstOrDefaultAsync((e) => e.Id == id);
return(entity);
}
}
public virtual async Task <bool> Delete(int id)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
T entity = await context.Set <T>().FirstOrDefaultAsync((e) => e.Id == id);
context.Set <T>().Remove(entity);
await context.SaveChangesAsync();
return(true);
}
}
public async Task <List <TestResult> > GetPersonalTestResults(Account currentAccount, string selectedSeries)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
TestSeries series = context.TestSeries
.Where(s => s.TestSeriesName == selectedSeries).FirstOrDefault();
return(await context.TestResults
.Include(q => q.Test)
.ThenInclude(qr => qr.TestSeries)
.Where(r => r.Account.Id == currentAccount.Id)
.Where(e => e.Test.TestSeries.Id == series.Id).ToListAsync());
}
}
public async Task UpdateSubTopicContents()
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
SubTopic subTopic = context.SubTopics.Where(s => s.Title == "SubTopic").FirstOrDefault();
SubTopic createdSubTopic = await subTopicService.UpdateSubTopic(subTopic.Id, "NewTitle", "NewIntro", "NewContent", "NewSummary");
}
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
SubTopic retrievedsubTopic = context.SubTopics.Where(s => s.Title == "NewTitle").FirstOrDefault();
Assert.AreEqual("NewTitle", retrievedsubTopic.Title);
Assert.AreEqual("NewIntro", retrievedsubTopic.Introduction);
}
}
public async Task <SubTopic> UpdateSubTopic(int subTopicId, string subTopicTitle, string subTopicIntro, string subTopicContent, string subTopicSummary)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
SubTopic retrievedSubTopic = context.SubTopics.Where(st => st.Id == subTopicId).FirstOrDefault();
retrievedSubTopic.Title = subTopicTitle;
retrievedSubTopic.Introduction = subTopicIntro;
retrievedSubTopic.Content = subTopicContent;
retrievedSubTopic.Summary = subTopicSummary;
context.Set <SubTopic>().Update(retrievedSubTopic);
await context.SaveChangesAsync();
return(retrievedSubTopic);
}
}
public async Task <Test> CreateNewTest(Test test, string seriesName)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
Test checkTest = context.Tests.Where(t => t.TestName == test.TestName).FirstOrDefault();
if (checkTest == null)
{
test.TestSeries = context.TestSeries
.Where(q => q.TestSeriesName == seriesName)
.FirstOrDefault();
EntityEntry <Test> createdResult = await context.Set <Test>().AddAsync(test);
await context.SaveChangesAsync();
return(createdResult.Entity);
}
return(null);
}
}
public override async Task <bool> Delete(int testId)
{
using (SelfAssessmentDbContext context = new SelfAssessmentDbContext())
{
List <QuestionOption> questionOptionsToDelete = await context.QuestionOptions
.Include(q => q.Question)
.ThenInclude(q => q.Test)
.Where(q => q.Question.Test.Id == testId)
.ToListAsync();
foreach (var questionOption in questionOptionsToDelete)
{
context.QuestionOptions.Remove(questionOption);
}
List <Question> questionsToDelete = await context.Questions
.Include(q => q.Test)
.Where(q => q.Test.Id == testId)
.ToListAsync();
foreach (var question in questionsToDelete)
{
context.Questions.Remove(question);
}
List <TestResult> resultsToDelete = await context.TestResults
.Include(q => q.Test)
.Where(q => q.Test.Id == testId)
.ToListAsync();
foreach (var testResult in resultsToDelete)
{
context.TestResults.Remove(testResult);
}
Test testToDelete = await context.Tests
.Where(t => t.Id == testId)
.FirstOrDefaultAsync();
context.Tests.Remove(testToDelete);
await context.SaveChangesAsync();
}
return(true);
}
