public async Task UpdateStudent()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("UpdateStudent")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Students.AddAsync(new Student { Id = 1, Name = "Jonas" });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new StudentRepository(context);
var student =
await new StudentController().Update(repository, 1, new NameData {
Name = "Jose"
}) as OkObjectResult;
Assert.NotNull(student);
Assert.Equal("Jose", ((Student)student.Value).Name);
}
}
public async Task GetOneTeacher()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("GetOneTeacher")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Teachers.AddAsync(new Teacher { Id = 1, Name = "Jonas" });
await context.Teachers.AddAsync(new Teacher { Id = 2, Name = "Pietra" });
await context.Teachers.AddAsync(new Teacher { Id = 3, Name = "Maria" });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new TeacherRepository(context);
var teacher = await new TeacherController().GetFromId(repository, 2) as OkObjectResult;
Assert.NotNull(teacher);
Assert.Equal("Pietra", ((Teacher)teacher.Value).Name);
}
}
public async Task AssignStudent()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("AssignStudent")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Students.AddAsync(new Student { Id = 1, Name = "Jonas" });
await context.Courses.AddAsync(new Course { Id = 1, Name = "Biology" });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new AssociationRepository(context);
var assign = await new AssociationController().AddStudentToCourse(repository,
new StudentCourseAssociation {
StudentId = 1, CourseId = 1
}) as OkObjectResult;
var association = await context.Attends.FirstAsync();
Assert.NotNull(assign);
Assert.NotNull(association);
Assert.Equal(1, ((Attend)assign.Value).Id);
}
}
public async Task UnassignTeacher()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("UnassignTeacher")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Teachers.AddAsync(new Teacher { Id = 1, Name = "Jonas" });
await context.Courses.AddAsync(new Course { Id = 1, Name = "Biology" });
await context.Teaches.AddAsync(new Teach { Id = 1, TeacherId = 1, CourseId = 1 });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new AssociationRepository(context);
var assign = await new AssociationController().RemoveTeacherFromCourse(repository,
new TeacherCourseAssociation {
TeacherId = 1, CourseId = 1
}) as OkResult;
var association = await context.Teaches.FindAsync(1);
Assert.NotNull(assign);
Assert.Null(association);
Assert.Equal(200, assign.StatusCode);
}
}
public async Task GetOneCourse()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("GetOneCourse")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Courses.AddAsync(new Course { Id = 1, Name = "Math" });
await context.Courses.AddAsync(new Course { Id = 2, Name = "Science" });
await context.Courses.AddAsync(new Course { Id = 3, Name = "Geography" });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new CourseRepository(context);
var course = await new CourseController().GetFromId(repository, 2) as OkObjectResult;
Assert.NotNull(course);
Assert.Equal("Science", ((Course)course.Value).Name);
}
}
public async Task GetTeacherCourses()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("GetTeacherCourses")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Teachers.AddAsync(new Teacher { Id = 1, Name = "Jonas" });
await context.Courses.AddAsync(new Course { Id = 1, Name = "Biology" });
await context.Teaches.AddAsync(new Teach { Id = 1, TeacherId = 1, CourseId = 1 });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new TeacherRepository(context);
var assign = await new TeacherController().GetCoursesFromId(repository, 1) as OkObjectResult;
Assert.NotNull(assign);
Assert.Single((List <Course>)assign.Value);
Assert.Equal(200, assign.StatusCode);
}
}
public async Task GetAllStudents()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("GetAllStudents")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Students.AddAsync(new Student { Id = 1, Name = "Jonas" });
await context.Students.AddAsync(new Student { Id = 2, Name = "Pietra" });
await context.Students.AddAsync(new Student { Id = 3, Name = "Maria" });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new StudentRepository(context);
var students = await new StudentController().Get(repository) as OkObjectResult;
Assert.NotNull(students);
Assert.Equal(3, ((List <Student>)students.Value).Count);
}
}
public async Task GetPagedTeachers()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("GetPagedTeachers")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Teachers.AddAsync(new Teacher { Id = 1, Name = "Jonas" });
await context.Teachers.AddAsync(new Teacher { Id = 2, Name = "Pietra" });
await context.Teachers.AddAsync(new Teacher { Id = 3, Name = "Maria" });
await context.Teachers.AddAsync(new Teacher { Id = 4, Name = "Henry" });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new TeacherRepository(context);
var teachers = await new TeacherController().Get(repository, 1, 2) as OkObjectResult;
Assert.NotNull(teachers);
Assert.Equal(2, ((PagedData <List <Teacher> >)teachers.Value).Value.Count);
}
}
static void Test()
{
using (var ctx = new ChallengeDbContext())
{
var dtos = ctx.Users.ProjectTo <UserDto>().ToList();
foreach (var userDto in dtos)
{
Console.WriteLine($"{userDto.FirstName} {userDto.Salary} {userDto.SalaryRatio}");
}
}
}
public async Task CreateCourse()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("CreateCourse")
.Options;
// Use a clean instance of the context to run the test
await using var context = new ChallengeDbContext(options);
var repository = new CourseRepository(context);
var course = await new CourseController().Create(repository, new NameData {
Name = "Marta"
}) as OkObjectResult;
Assert.NotNull(course);
Assert.Equal("Marta", ((Course)course.Value).Name);
}
public CompetitionRepositoryTest()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new EntityToDomainMapper());
});
_mapper = config.CreateMapper();
var optionsBuilder = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase(databaseName: "CompetitionRepositoryTest")
.Options;
_context = new ChallengeDbContext(optionsBuilder);
if (_context.Competitions.ToList().Count == 0)
{
_context.Competitions.AddRange(GetFakeListOfCompetitions());
_context.SaveChanges();
}
}
static void ImportCsvData()
{
var lines = File.ReadAllLines(@"..\..\MOCK_DATA.csv");
using (var ctx = new ChallengeDbContext())
{
foreach (var line in lines.Skip(1))
{
var split = line.Split(',');
var user = new User
{
FirstName = split[0],
LastName = split[1],
Phone = split[2],
Salary = decimal.Parse(split[3], CultureInfo.InvariantCulture)
};
ctx.Users.Add(user);
}
ctx.SaveChanges();
}
}
public async Task DeleteTeacher()
{
var options = new DbContextOptionsBuilder <ChallengeDbContext>()
.UseInMemoryDatabase("DeleteTeacher")
.Options;
// Insert seed data into the database using one instance of the context
await using (var context = new ChallengeDbContext(options))
{
await context.Teachers.AddAsync(new Teacher { Id = 1, Name = "Jonas" });
await context.SaveChangesAsync();
}
// Use a clean instance of the context to run the test
await using (var context = new ChallengeDbContext(options))
{
var repository = new TeacherRepository(context);
_ = await new TeacherController().Delete(repository, 1) as OkObjectResult;
var teachers = await context.Teachers.FindAsync(1);
Assert.Null(teachers);
}
}
public PlayerRepository(ChallengeDbContext context, IMapper mapper)
{
_context = context;
_mapper = mapper;
}
public AssociationRepository(ChallengeDbContext dbContext)
{
_dbContext = dbContext;
}
public CompetitionRepository(ChallengeDbContext context, IMapper mapper)
{
_context = context;
_mapper = mapper;
}
public CourseRepository(ChallengeDbContext dbContext)
{
_dbContext = dbContext;
}
public StudentRepository(ChallengeDbContext dbContext)
{
_dbContext = dbContext;
}
public TeacherRepository(ChallengeDbContext dbContext)
{
_dbContext = dbContext;
}
