public async Task GetClassroomAdminsAsync_ReturnsAdmins()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddClassroom("Class2")
.AddAdmin("User1", "Last", "First", "Class1", superUser: false)
.AddAdmin("User2", "Last", "First", "Class1", superUser: false)
.AddAdmin("User3", "Last", "First", "Class2", superUser: false)
.Build();
var users = database.Context.Users
.OrderBy(u => u.UserName)
.ToList();
database.Reload();
var classroomService = GetClassroomService(database.Context);
var admins = await classroomService.GetClassroomAdminsAsync("Class1");
admins = admins.OrderBy(a => a.UserId).ToList();
Assert.Equal(2, admins.Count);
Assert.Equal(users[0].Id, admins[0].UserId);
Assert.Equal(users[1].Id, admins[1].UserId);
}
public async Task DeleteQuestionAsync_QuestionDeleted()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new MethodQuestion()
{
Name = "Question1"
})
.Build();
var questionId = database.Context.Questions.First().Id;
database.Reload();
var loaderFactory = GetMockQuestionLoaderFactory();
var questionService = CreateQuestionService
(
database.Context,
questionLoaderFactory: loaderFactory.Object
);
await questionService.DeleteQuestionAsync
(
"Class1",
questionId
);
database.Reload();
Assert.Equal(0, database.Context.Questions.Count());
}
public void Build_fills_in_names_if_StorageName_not_specified()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity <Blog>(b =>
{
b.Key(k => k.BlogId);
b.Property(e => e.BlogId);
});
modelBuilder.Entity <Post>(b =>
{
b.Key(k => k.PostId);
b.Property(e => e.PostId);
b.Property(e => e.BelongsToBlogId);
b.ForeignKey <Blog>(p => p.BelongsToBlogId);
b.Index(ix => ix.PostId);
});
var database = new TestDatabaseBuilder().GetDatabase(modelBuilder.Model);
Assert.True(database.Tables.Any(t => t.Name == "Blog"));
Assert.True(database.Tables.Any(t => t.Name == "Post"));
Assert.Equal("BlogId", database.GetTable("Blog").Columns.Single().Name);
Assert.Equal("PostId", database.GetTable("Post").Columns[0].Name);
Assert.Equal("BelongsToBlogId", database.GetTable("Post").Columns[1].Name);
Assert.Equal("PK_Blog", database.GetTable("Blog").PrimaryKey.Name);
Assert.Equal("PK_Post", database.GetTable("Post").PrimaryKey.Name);
Assert.Equal("FK_Post_Blog_BelongsToBlogId", database.GetTable("Post").ForeignKeys.Single().Name);
Assert.Equal("IX_Post_PostId", database.GetTable("Post").Indexes.Single().Name);
}
public async Task ArchiveClassroomAsync_ClassrooFound_ReturnsTrueAndArchivesClassroom()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.Build();
var mockArchiver = new Mock <IClassroomArchiver>();
mockArchiver
.Setup(a => a.ArchiveClassroomAsync("Class1", "Class1A"))
.Returns(Task.CompletedTask);
var classroomService = GetClassroomService
(
database.Context,
mockArchiver.Object
);
var result = await classroomService.ArchiveClassroomAsync
(
"Class1",
"Class1A"
);
Assert.True(result);
mockArchiver.Verify(a => a.ArchiveClassroomAsync("Class1", "Class1A"));
}
public async Task GetClassroomsWithAccessAsync_SuperUser_ReturnsClassrooms()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddClassroom("Class2")
.AddAdmin("User1", "Last", "First", "Class2", superUser: true)
.Build();
var userId = database.Context.Users.First().Id;
var expectedClassrooms = database.Context.Classrooms
.OrderBy(c => c.Id)
.ToList();
database.Reload();
var classroomService = GetClassroomService(database.Context);
var classrooms = await classroomService.GetClassroomsWithAccessAsync(userId);
classrooms = classrooms.OrderBy(c => c.ClassroomId).ToList();
Assert.Equal(2, classrooms.Count);
Assert.Equal(userId, classrooms[0].UserId);
Assert.Equal(expectedClassrooms[0].Id, classrooms[0].ClassroomId);
Assert.Equal(userId, classrooms[1].UserId);
Assert.Equal(expectedClassrooms[1].Id, classrooms[1].ClassroomId);
}
public async Task DuplicateExistingQuestionAsync_ReturnDuplicate()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new MethodQuestion()
{
Name = "Question1"
})
.Build();
var questionId = database.Context.Questions.First().Id;
database.Reload();
var loaderFactory = GetMockQuestionLoaderFactory();
var duplicatorFactory = GetMockQuestionDuplicatorFactory();
var questionService = CreateQuestionService
(
database.Context,
questionLoaderFactory: loaderFactory.Object,
questionDuplicatorFactory: duplicatorFactory.Object
);
var question = await questionService.DuplicateExistingQuestionAsync
(
"Class1",
questionId
);
loaderFactory.Verify(LoadQuestionExpression);
duplicatorFactory.Verify(DuplicateQuestionExpression);
Assert.Equal("Question1 (duplicated)", question.Name);
}
public void Build_fills_in_unique_constraint_name_if_not_specified()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("A",
b =>
{
var id = b.Property <int>("Id").Metadata;
var p1 = b.Property <long>("P1").ForRelational(rb => rb.Column("C1")).Metadata;
var p2 = b.Property <string>("P2").Metadata;
b.Key("Id").ForRelational().Name("PK");
b.Metadata.AddKey(new[] { id, p1 });
b.Metadata.AddKey(new[] { p2 });
});
var database = new TestDatabaseBuilder().GetDatabase(modelBuilder.Model);
var table = database.Tables[0];
Assert.Equal(2, table.UniqueConstraints.Count);
Assert.Equal("UC_A_Id_C1", table.UniqueConstraints[0].Name);
Assert.Equal("UC_A_P2", table.UniqueConstraints[1].Name);
modelBuilder.Entity("A").ForRelational().Table("T", "dbo");
database = new TestDatabaseBuilder().GetDatabase(modelBuilder.Model);
table = database.Tables[0];
Assert.Equal(2, table.UniqueConstraints.Count);
Assert.Equal("UC_dbo.T_Id_C1", table.UniqueConstraints[0].Name);
Assert.Equal("UC_dbo.T_P2", table.UniqueConstraints[1].Name);
}
public async Task CreateSectionAsync_InvalidSection_SectionNotCreated()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.Build();
var section = new Section()
{
Name = "Section1"
};
var errors = new MockErrorCollection();
var validator = CreateMockSectionValidator(section, errors, valid: false);
var sectionService = CreateSectionService(database.Context, validator);
var result = await sectionService.CreateSectionAsync("Class1", section, errors);
database.Reload();
section = database.Context.Sections
.Include(qc => qc.Classroom)
.SingleOrDefault();
Assert.False(result);
Assert.True(errors.HasErrors);
Assert.Null(section);
}
public void Build_creates_unique_constraints()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("A",
b =>
{
var id = b.Property <int>("Id").Metadata;
var p1 = b.Property <long>("P1").ForRelational(rb => rb.Column("C1")).Metadata;
var p2 = b.Property <string>("P2").Metadata;
b.Key("Id").ForRelational().Name("PK");
b.Metadata.AddKey(new[] { id, p1 }).Relational().Name = "UC1";
b.Metadata.AddKey(new[] { p2 }).Relational().Name = "UC2";
});
var database = new TestDatabaseBuilder().GetDatabase(modelBuilder.Model);
Assert.Equal(1, database.Tables.Count);
var table = database.Tables[0];
Assert.Equal(2, table.UniqueConstraints.Count);
Assert.Equal("UC1", table.UniqueConstraints[0].Name);
Assert.Equal(new[] { "Id", "C1" }, table.UniqueConstraints[0].Columns.Select(c => c.Name));
Assert.Equal("UC2", table.UniqueConstraints[1].Name);
Assert.Equal(new[] { "P2" }, table.UniqueConstraints[1].Columns.Select(c => c.Name));
Assert.NotNull(table.PrimaryKey);
Assert.Equal("PK", table.PrimaryKey.Name);
}
public async Task CreateQuestionCategoryAsync_CategoryCreated()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.Build();
var questionCategoryService = new QuestionCategoryService(database.Context);
await questionCategoryService.CreateQuestionCategoryAsync
(
"Class1",
new QuestionCategory()
{
Name = "Category1"
}
);
database.Reload();
var questionCategory = database.Context.QuestionCategories
.Include(qc => qc.Classroom)
.Single();
Assert.Equal("Class1", questionCategory.Classroom.Name);
Assert.Equal("Category1", questionCategory.Name);
}
public async Task UpdateQuestionCategoryAsync_CategoryUpdated()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.Build();
var questionCategory = database.Context.QuestionCategories
.Include(qc => qc.Classroom)
.First();
// Update the category
database.Context.Entry(questionCategory).State = EntityState.Detached;
questionCategory.Name = "Category1Updated";
// Apply the update
var questionCategoryService = new QuestionCategoryService(database.Context);
await questionCategoryService.UpdateQuestionCategoryAsync
(
"Class1",
questionCategory
);
database.Reload();
questionCategory = database.Context.QuestionCategories
.Include(qc => qc.Classroom)
.Single();
Assert.Equal("Class1", questionCategory.Classroom.Name);
Assert.Equal("Category1Updated", questionCategory.Name);
}
public async Task GetQuestionInstanceAsync_InvalidQuestionType_Throws()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new MethodQuestion()
{
Name = "Question1"
})
.Build();
var questionId = database.Context
.Questions
.First()
.Id;
var loaderFactory = GetMockQuestionLoaderFactory();
var questionService = CreateQuestionService
(
database.Context,
questionLoaderFactory: loaderFactory.Object
);
await Assert.ThrowsAsync <InvalidOperationException>
(
async() => await questionService.GetQuestionInstanceAsync
(
"Class1",
id: questionId,
seed: 100
)
);
}
public async Task GenerateFromExistingQuestionAsync_FromRandomlySelectedQuestion_Throws()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new RandomlySelectedQuestion()
{
Name = "Question1"
})
.Build();
var originalQuestion = database.Context.Questions.First();
database.Reload();
var loaderFactory = GetMockQuestionLoaderFactory();
var questionService = CreateQuestionService
(
database.Context,
questionLoaderFactory: loaderFactory.Object
);
await Assert.ThrowsAsync <InvalidOperationException>
(
async() => await questionService.GenerateFromExistingQuestionAsync
(
"Class1",
originalQuestion.Id
)
);
}
public async Task UpdateSectionAsync_ValidSection_SectionUpdated()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddSection("Class1", "Section1")
.Build();
var section = database.Context.Sections
.Include(qc => qc.Classroom)
.First();
// Update the section
database.Context.Entry(section).State = EntityState.Detached;
section.DisplayName = "New Display Name";
// Apply the update
var errors = new MockErrorCollection();
var validator = CreateMockSectionValidator(section, errors, valid: true);
var sectionService = CreateSectionService(database.Context, validator);
var result = await sectionService.UpdateSectionAsync("Class1", section, errors);
database.Reload();
section = database.Context.Sections
.Include(qc => qc.Classroom)
.Single();
Assert.True(result);
Assert.False(errors.HasErrors);
Assert.Equal("Class1", section.Classroom.Name);
Assert.Equal("Section1", section.Name);
Assert.Equal("New Display Name", section.DisplayName);
}
public void Columns_are_ordered_by_name_with_pk_columns_first_and_fk_columns_last()
{
var modelBuider = new BasicModelBuilder();
modelBuider.Entity("A",
b =>
{
b.Property <int>("Px");
b.Property <int>("Py");
b.Key("Px", "Py");
});
modelBuider.Entity("B",
b =>
{
b.Property <int>("P6");
b.Property <int>("P5");
b.Property <int>("P4");
b.Property <int>("P3");
b.Property <int>("P2");
b.Property <int>("P1");
b.Key("P5", "P2");
b.ForeignKey("A", "P6", "P4");
b.ForeignKey("A", "P4", "P5");
});
var databaseModel = new TestDatabaseBuilder().GetDatabase(modelBuider.Model);
Assert.Equal(2, databaseModel.Tables.Count);
Assert.Equal(new[] { "Px", "Py" }, databaseModel.Tables[0].Columns.Select(c => c.Name));
Assert.Equal(new[] { "P5", "P2", "P1", "P3", "P6", "P4" }, databaseModel.Tables[1].Columns.Select(c => c.Name));
}
public async Task GetClassroomsWithAccessAsync_UserNotFound_ReturnsNull()
{
var database = new TestDatabaseBuilder().Build();
var classroomService = GetClassroomService(database.Context);
var classrooms = await classroomService.GetClassroomsWithAccessAsync(userId : 100);
Assert.Equal(0, classrooms.Count);
}
public void Build_creates_database()
{
var database = new TestDatabaseBuilder().GetDatabase(CreateModel());
Assert.NotNull(database);
Assert.Equal(2, database.Tables.Count);
var table0 = database.Tables[0];
var table1 = database.Tables[1];
Assert.Equal("dbo.MyTable0", table0.Name);
Assert.Equal(1, table0.Columns.Count);
Assert.Equal("Id", table0.Columns[0].Name);
Assert.Equal("int", table0.Columns[0].DataType);
Assert.Equal(ValueGeneration.None, table0.Columns[0].ValueGenerationStrategy);
Assert.NotNull(table1.PrimaryKey.Name);
Assert.Equal("MyPK0", table0.PrimaryKey.Name);
Assert.Same(table0.Columns[0], table0.PrimaryKey.Columns[0]);
Assert.Equal(1, table0.ForeignKeys.Count);
Assert.Equal("dbo.MyTable1", table1.Name);
Assert.Equal(2, table1.Columns.Count);
Assert.Equal("Id", table1.Columns[0].Name);
Assert.Equal("int", table1.Columns[0].DataType);
Assert.Equal(ValueGeneration.OnAdd, table1.Columns[0].ValueGenerationStrategy);
Assert.Null(table1.Columns[0].MaxLength);
Assert.NotNull(table1.PrimaryKey.Name);
Assert.Equal("MyPK1", table1.PrimaryKey.Name);
Assert.Same(table1.Columns[0], table1.PrimaryKey.Columns[0]);
Assert.Equal(0, table1.ForeignKeys.Count);
Assert.Equal("Name", table1.Columns[1].Name);
Assert.Null(table1.Columns[1].DataType);
Assert.Equal(ValueGeneration.None, table1.Columns[1].ValueGenerationStrategy);
Assert.Equal(256, table1.Columns[1].MaxLength);
var foreignKey = table0.ForeignKeys[0];
Assert.Equal("MyFK", foreignKey.Name);
Assert.Same(table0, foreignKey.Table);
Assert.Same(table1, foreignKey.ReferencedTable);
Assert.Same(table0.Columns[0], foreignKey.Columns[0]);
Assert.Same(table1.Columns[0], foreignKey.ReferencedColumns[0]);
// TODO: Cascading behaviors not supported. Issue #333
//Assert.True(foreignKey.CascadeDelete);
var index = table0.Indexes[0];
Assert.Equal("MyIndex", index.Name);
Assert.Same(table0, index.Table);
Assert.Same(table0.Columns[0], index.Columns[0]);
Assert.True(index.IsUnique);
}
public async Task GetClassroomAsync_DoesntExist_ReturnNull()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.Build();
var classroomService = GetClassroomService(database.Context);
var classroom = await classroomService.GetClassroomAsync("Class2");
Assert.Null(classroom);
}
static ClientStoreFixture()
{
TestDatabases = new TheoryData <TestDatabase>()
{
TestDatabaseBuilder.SQLServer2012TestDatabase(SQLServerConnectionString, $"{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}_NH_Test", TestConfigurationStoreOptions, TestOperationalStoreOptions),
TestDatabaseBuilder.SQLiteTestDatabase($"{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}_NH_Test.sqlite", TestConfigurationStoreOptions, TestOperationalStoreOptions),
TestDatabaseBuilder.SQLiteInMemoryTestDatabase(TestConfigurationStoreOptions, TestOperationalStoreOptions),
TestDatabaseBuilder.PostgreSQLTestDatabase(PostgreSQLConnectionString, $"{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}_NH_Test", TestConfigurationStoreOptions, TestOperationalStoreOptions),
TestDatabaseBuilder.MySQLTestDatabase(MySQLConnectionString, $"{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}_NH_Test", TestConfigurationStoreOptions, TestOperationalStoreOptions)
};
}
public async Task GetProjectAsync_DoesntExist_ReturnNull()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.Build();
var projectService = GetProjectService(database.Context);
var project = await projectService.GetProjectAsync("Class1", "Project1");
Assert.Null(project);
}
static ClientStoreFixture()
{
var sqlServerDataSource = TestSettings["SQLServer"];
TestDatabases = new TheoryData <TestDatabase>()
{
TestDatabaseBuilder.SQLServer2012TestDatabase(sqlServerDataSource, $"{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}_NH_Test", TestConfigurationStoreOptions, TestOperationalStoreOptions),
TestDatabaseBuilder.SQLiteTestDatabase($"{MethodBase.GetCurrentMethod()?.DeclaringType?.Name}_NH_Test.sqlite", TestConfigurationStoreOptions, TestOperationalStoreOptions),
TestDatabaseBuilder.SQLiteInMemoryTestDatabase(TestConfigurationStoreOptions, TestOperationalStoreOptions)
};
}
public async Task GetSectionAsync_DoesntExist_ReturnNull()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.Build();
var sectionService = CreateSectionService(database.Context);
var section = await sectionService.GetSectionAsync("Class1", "Section1");
Assert.Null(section);
}
public async Task GetQuestionChoicesAsync_ReturnsAllChoices()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddClassroom("Class2")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new RandomlySelectedQuestion()
{
Name = "Question1",
ChoicesCategory = new QuestionCategory()
{
Name = "ChoicesCategory",
Questions = Collections.CreateList
(
new MethodQuestion()
{
Name = "Choice1"
},
new MethodQuestion()
{
Name = "Choice2"
}
).Cast <Question>().ToList()
}
})
.AddQuestion("Class1", "Category1", new MultipleChoiceQuestion()
{
Name = "OtherQuestion"
})
.Build();
var questionId = database.Context
.RandomlySelectedQuestions
.Single()
.Id;
var questionService = CreateQuestionService(database.Context);
var choicesCategory = await questionService.GetQuestionChoicesAsync
(
"Class1",
questionId
);
var orderedQuestions = choicesCategory.Questions
.OrderBy(q => q.Name)
.ToList();
Assert.Equal(2, orderedQuestions.Count);
Assert.Equal("Class1", orderedQuestions[0].QuestionCategory.Classroom.Name);
Assert.Equal("Choice1", orderedQuestions[0].Name);
Assert.Equal("Class1", orderedQuestions[1].QuestionCategory.Classroom.Name);
Assert.Equal("Choice2", orderedQuestions[1].Name);
}
public async Task UpdateQuestionCategoryAsync_InvalidQuestion_QuestionNotUpdated(
bool validatorIsValid,
bool updaterIsValid)
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new MethodQuestion()
{
Name = "Question1"
})
.AddQuestion("Class1", "Category1", new MethodQuestion()
{
Name = "Question2"
})
.Build();
var modelErrors = new MockErrorCollection();
var validator = GetMockQuestionValidator(validatorIsValid);
var updaterFactory = GetMockQuestionUpdaterFactory(updaterIsValid);
var question = database.Context.Questions
.Single(q => q.Name == "Question2");
database.Context.Entry(question).State = EntityState.Detached;
question.AllowPartialCredit = true;
var questionService = CreateQuestionService
(
database.Context,
questionUpdaterFactory: updaterFactory.Object,
questionValidator: validator.Object
);
var result = await questionService.UpdateQuestionAsync
(
"Class1",
question,
modelErrors
);
Assert.False(result);
Assert.True(modelErrors.VerifyErrors("Error"));
database.Reload();
var questionCounts = database.Context.Questions
.GroupBy(q => q.Name)
.ToDictionary(g => g.Key, g => g.Count());
Assert.Equal(2, questionCounts.Count);
Assert.Equal(1, questionCounts["Question1"]);
Assert.Equal(1, questionCounts["Question2"]);
}
public async Task GenerateFromExistingQuestionAsync_ReturnsMatchingGeneratorTemplate()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new MethodQuestion()
{
Name = "Question1"
})
.Build();
var originalQuestion = database.Context.Questions.First();
database.Reload();
var loaderFactory = GetMockQuestionLoaderFactory();
var questionGenerator = GetMockQuestionGenerator
(
originalQuestion.Id
);
var questionService = CreateQuestionService
(
database.Context,
questionLoaderFactory: loaderFactory.Object,
questionGenerator: questionGenerator.Object
);
var generatedQuestion = (GeneratedQuestionTemplate)
await questionService.GenerateFromExistingQuestionAsync
(
"Class1",
originalQuestion.Id
);
loaderFactory.Verify(LoadQuestionExpression);
Assert.Equal("Question1 (generated)", generatedQuestion.Name);
Assert.Equal("Generated Question Template", generatedQuestion.Description);
Assert.Equal(originalQuestion.QuestionCategoryId, generatedQuestion.QuestionCategoryId);
Assert.Single(generatedQuestion.ImportedClasses);
Assert.Equal("java.util.*", generatedQuestion.ImportedClasses[0].ClassName);
var expectedContents =
"public class QuestionGenerator\n"
+ "{\n"
+ " public static Question generateQuestion(int seed)\n"
+ " {\n"
+ " QuestionConstructorInvocation\n"
+ " }\n"
+ "}\n";
Assert.Equal(expectedContents, generatedQuestion.GeneratorContents);
}
public DatabaseFixture()
{
TestDatabase = new TestDatabaseBuilder()
.WithConnectionString("Data Source=/tmp/domain.db")
.Build();
TestDatabase.Create();
var builder = new DbContextOptionsBuilder <DomainContext>()
.UseSqlite(TestDatabase.ConnectionString);
DbContext = new DomainContext(builder.Options);
DbContext.Database.EnsureCreated();
}
public DatabaseFixture()
{
var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
TestDatabase = new TestDatabaseBuilder().WithConfiguration(configuration).WithTemplateDatabase("uuid_extension_enabled").Build();
TestDatabase.Create();
var builder = new DbContextOptionsBuilder <TestDbContext>();
builder.UseNpgsql(TestDatabase.ConnectionString);
DbContext = new TestDbContext(builder.Options);
DbContext.Database.EnsureCreated();
}
public async Task GetQuestionInstanceAsync_NoGenerationError_ReturnsQuestionInstance()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new GeneratedQuestionTemplate()
{
Name = "Question1"
})
.Build();
var questionId = database.Context
.Questions
.First()
.Id;
var loaderFactory = GetMockQuestionLoaderFactory();
var generator = GetMockQuestionGenerator
(
questionId,
seed: 12345,
error: false,
result: "SerializedQuestion"
);
var expectedResult = new MethodQuestion();
var jsonSerializer = GetMockJsonSerializer <Question>
(
"SerializedQuestion",
expectedResult
);
var questionService = CreateQuestionService
(
database.Context,
questionLoaderFactory: loaderFactory.Object,
questionGenerator: generator.Object,
jsonSerializer: jsonSerializer.Object
);
var result = await questionService.GetQuestionInstanceAsync
(
"Class1",
id : 1,
seed : 12345
);
loaderFactory.Verify(LoadQuestionExpression);
Assert.Equal(expectedResult, result.Question);
Assert.Equal(12345, result.Seed);
}
public async Task GetClassroomsAsync_ReturnsAllClassrooms()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddClassroom("Class2")
.Build();
var classroomService = GetClassroomService(database.Context);
var classrooms = await classroomService.GetClassroomsAsync();
Assert.Equal(2, classrooms.Count);
Assert.Equal("Class1", classrooms[0].Name);
Assert.Equal("Class1", classrooms[0].Name);
}
public async Task CreateCheckpointAsync_DuplicateSectionDueDates_CheckpointNotCreated()
{
var database = new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddSection("Class1", "Period1")
.AddSection("Class1", "Period2")
.AddProject("Class1", "Project1")
.Build();
var sections = database.Context.Sections.ToList();
database.Reload();
var modelErrors = new MockErrorCollection();
var checkpointService = GetCheckpointService(database.Context);
var result = await checkpointService.CreateCheckpointAsync
(
"Class1",
"Project1",
new Checkpoint()
{
Name = "Checkpoint1",
DisplayName = "Checkpoint1 DisplayName",
SectionDates = Collections.CreateList
(
new CheckpointDates()
{
SectionId = sections[0].Id,
DueDate = Period1DueDate
},
new CheckpointDates()
{
SectionId = sections[0].Id,
DueDate = Period2DueDate
}
)
},
modelErrors
);
database.Reload();
var checkpoint = database.Context.Checkpoints.SingleOrDefault();
Assert.False(result);
Assert.True(modelErrors.HasErrors);
Assert.True(modelErrors.VerifyErrors("SectionDates"));
Assert.Null(checkpoint);
}
