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); }