public async void Create_ErrorsOccurred_ShouldReturnErrorResponse()
{
var mock = new ServiceMockFacade <ITeacherService, ITeacherRepository>();
var model = new ApiTeacherServerRequestModel();
var validatorMock = new Mock <IApiTeacherServerRequestModelValidator>();
validatorMock.Setup(x => x.ValidateCreateAsync(It.IsAny <ApiTeacherServerRequestModel>())).Returns(Task.FromResult(new FluentValidation.Results.ValidationResult(new List <ValidationFailure>()
{
new ValidationFailure("text", "test")
})));
var service = new TeacherService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
validatorMock.Object,
mock.DALMapperMockFactory.DALTeacherMapperMock,
mock.DALMapperMockFactory.DALEventTeacherMapperMock,
mock.DALMapperMockFactory.DALRateMapperMock,
mock.DALMapperMockFactory.DALTeacherTeacherSkillMapperMock);
CreateResponse <ApiTeacherServerResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
response.Success.Should().BeFalse();
validatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiTeacherServerRequestModel>()));
mock.MediatorMock.Verify(x => x.Publish(It.IsAny <TeacherCreatedNotification>(), It.IsAny <CancellationToken>()), Times.Never());
}
public TeacherViewModel Create(TeacherPostModel model)
{
if (model.FirstName.Contains(" "))
{
return(new TeacherViewModel {
FirstName = "validation PL error", LastName = "Errorovich"
});
}
var teacherModel = new TeacherModel
{
FirstName = model.FirstName,
LastName = model.LastName,
LicenseNum = model.LicenseNum
};
var createResult = _teachersService.Create(teacherModel);
var result = new TeacherViewModel
{
Id = createResult.Id,
FirstName = createResult.FirstName,
LastName = createResult.LastName
};
return(result);
}
public void Create_TeacherWithData_NewTeacher()
{
var newTeacher = new DataPlus.Entities.Models.Teacher
{
Id = Guid.NewGuid(),
DocumentNumber = "5555555",
FirstName = "Jose",
LastName = "Santos",
Email = "*****@*****.**",
Address = "Street 5",
City = "City 2",
DocumentType = EDocumentType.CC,
PhoneNumber = "722222",
Birth = new DateTime(1965, 5, 5)
};
var repositoryWrapper = new Mock <IWrapperRepository>();
repositoryWrapper.Setup(x => x.Teacher.GetAll()).Returns(_teacherList.AsQueryable);
var teacherService = new TeacherService(repositoryWrapper.Object, _logger);
var numberOfTeachers = teacherService.GetAll().Count;
teacherService.Create(newTeacher);
}
public void Create_EmptyTeacher_Exception()
{
var newTeacher = new DataPlus.Entities.Models.Teacher();
var repositoryWrapper = new Mock <IWrapperRepository>();
var teacherService = new TeacherService(repositoryWrapper.Object, _logger);
Assert.Throws <NullReferenceException>(() => teacherService.Create(newTeacher));
}
public async System.Threading.Tasks.Task AddTeacher_ToCourse_TestAsync()
{
var options = new DbContextOptionsBuilder <OlpContext>()
.UseInMemoryDatabase(databaseName: "Add_writes_to_database_TeacherCourses")
.Options;
// Run the test against one instance of the context
using (var context = new OlpContext(options))
{
Teacher teacher = new Domain.Teacher()
{
FirstName = "Test Name",
LastName = "Test last name",
Email = "test email",
};
var teacherService = new TeacherService(context);
await teacherService.Create(teacher);
Teacher fecthedTeacher = await teacherService.FindBy(x => x.FirstName == teacher.FirstName);
Assert.AreEqual(fecthedTeacher.FirstName, teacher.FirstName);
Course course = new Domain.Course()
{
Name = "Test course name",
Description = "test course desc",
};
var courseService = new CourseService(context);
await courseService.Create(course);
Course fecthedCourse = await courseService.FindBy(x => x.Name == course.Name);
Assert.AreEqual(fecthedCourse.Name, course.Name);
//teacher.TeacherCourses.Add(course);
TeacherCourse teacherCourse = new TeacherCourse()
{
Course = course,
Teacher = teacher
};
context.Add(teacherCourse);
context.SaveChanges();
TeacherCourse fecthedTeacherCourse = context.TeacherCourses.FirstOrDefaultAsync().Result;
Assert.AreEqual(fecthedTeacherCourse.Teacher.UserId, teacher.UserId);
fecthedCourse = await courseService.FindBy(x => x.Name == course.Name);
Assert.AreEqual(fecthedCourse.TeacherCourses.Count, 1);
//Assert.AreEqual(teacher.TeacherCourses, teacherCourse.Course);
}
}
static int AddScript0()
{
Teacher model = new Teacher()
{
Name = "Random Teacher", PassportData = 456278
};
DateTime startTime = DateTime.Now;
TeacherService.Create(model);
DateTime finishTime = DateTime.Now;
return((int)(finishTime - startTime).TotalMilliseconds);
}
public ActionResult Create(TeacherViewModel model)
{
try
{
// TODO: Add insert logic here
TeacherService.Create(model);
//teacherlist.Add(model);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Create([Bind("TeacherId,CNP,FirstName,LastName,MailAddress,Password,Address,Birthday")] Teacher teacher)
{
var user = new IdentityUser {
UserName = teacher.MailAddress, Email = teacher.MailAddress
};
var result = await userManager.CreateAsync(user, teacher.Password);
if (ModelState.IsValid)
{
await userManager.AddToRoleAsync(user, "Teacher");
teacherService.Create(teacher);
return(RedirectToAction(nameof(Index)));
}
return(View(teacher));
}
public ActionResult Create(TeacherViewModel item)
{
if (ModelState.IsValid)
{
teacherService.Create(new TeacherDTO
{
MiddleName = item.MiddleName,
Position = item.Position,
Name = item.Name,
SurName = item.SurName
});
}
else
{
ModelState.AddModelError("", "incorrect data");
}
return(RedirectToAction("Index"));
}
public async void Create()
{
var mock = new ServiceMockFacade <ITeacherRepository>();
var model = new ApiTeacherRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Teacher>())).Returns(Task.FromResult(new Teacher()));
var service = new TeacherService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TeacherModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTeacherMapperMock,
mock.DALMapperMockFactory.DALTeacherMapperMock,
mock.BOLMapperMockFactory.BOLRateMapperMock,
mock.DALMapperMockFactory.DALRateMapperMock);
CreateResponse <ApiTeacherResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
mock.ModelValidatorMockFactory.TeacherModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiTeacherRequestModel>()));
mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Teacher>()));
}
public async void Create_NoErrorsOccurred_ShouldReturnResponse()
{
var mock = new ServiceMockFacade <ITeacherService, ITeacherRepository>();
var model = new ApiTeacherServerRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Teacher>())).Returns(Task.FromResult(new Teacher()));
var service = new TeacherService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TeacherModelValidatorMock.Object,
mock.DALMapperMockFactory.DALTeacherMapperMock,
mock.DALMapperMockFactory.DALEventTeacherMapperMock,
mock.DALMapperMockFactory.DALRateMapperMock,
mock.DALMapperMockFactory.DALTeacherTeacherSkillMapperMock);
CreateResponse <ApiTeacherServerResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
response.Success.Should().BeTrue();
mock.ModelValidatorMockFactory.TeacherModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiTeacherServerRequestModel>()));
mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Teacher>()));
mock.MediatorMock.Verify(x => x.Publish(It.IsAny <TeacherCreatedNotification>(), It.IsAny <CancellationToken>()));
}
public void InheritanceTesti()
{
var options = new DbContextOptionsBuilder <OLP_Context>()
.UseInMemoryDatabase(databaseName: "InheritanceTest")
.Options;
using (var context = new OLP_Context(options))
{
//stud 1
Domain.Student student = new Domain.Student()
{
FirstName = "Daniel",
LastName = "Zeimo",
Email = "*****@*****.**",
};
var studentService = new UserService(context);
studentService.Create(student);
Domain.User fetchedUser = studentService.FindBy(x => x.FirstName == student.FirstName);
Assert.AreEqual(fetchedUser.FirstName, student.FirstName);
Console.Write("Stud inserted");
//stud 2
Domain.Student student2 = new Domain.Student()
{
FirstName = "Lukas",
LastName = "Velycka",
Email = "*****@*****.**",
};
var student1Service = new UserService(context);
student1Service.Create(student2);
Domain.User fetchedUser2 = student1Service.FindBy(x => x.FirstName == student2.FirstName);
Assert.AreEqual(fetchedUser2.FirstName, student2.FirstName);
Console.Write("Stud 2 inserted");
//stud 3
Domain.Student student3 = new Domain.Student()
{
FirstName = "Airidas",
LastName = "Amsejus",
Email = "*****@*****.**",
};
var student2Service = new UserService(context);
student2Service.Create(student3);
Domain.User fetchedUser3 = student2Service.FindBy(x => x.FirstName == student3.FirstName);
Assert.AreEqual(fetchedUser3.FirstName, student3.FirstName);
Console.Write("Stud 3 inserted");
//teach 1
Domain.Teacher teacher = new Domain.Teacher()
{
FirstName = "Nerijus",
LastName = "Muranovas",
Email = "*****@*****.**",
};
var teacherService = new TeacherService(context);
teacherService.Create(teacher);
Domain.Teacher fetchedTeacher = teacherService.FindBy(x => x.FirstName == teacher.FirstName);
Assert.AreEqual(teacher.FirstName, teacher.FirstName);
Console.Write("Teacher inserted");
//StudentService studentServiceF = new StudentService
}
}
