private void Setup()
{
var studentAssessmentToEnterResultsStudentModelMapper =
Substitute.For <IMapper <StudentAssessment, EnterResultsStudentModel> >();
studentAssessmentToEnterResultsStudentModelMapper.Build(Arg.Any <StudentAssessment>())
.Returns(new EnterResultsStudentModel());
var downloader = Substitute.For <IFileDownloader>();
_profilePhotoUrlFetcher = Substitute.For <ProfilePhotoUrlFetcher>(downloader);
_mapper = new AssessmentToEnterResultsModelMapper(studentAssessmentToEnterResultsStudentModelMapper, _profilePhotoUrlFetcher);
_profilePhotoUrlFetcher.GetProfilePhotoThumbnailUrlOrDefault(Arg.Any <Int32>()).Returns("/Assets/Images/placeholder.png");
_entity = new AssessmentBuilder()
.WithAssessmentLearningStandards()
.WithAssessmentPerformanceLevels()
.Build();
Web.Data.Entities.Student student1 = new StudentBuilder().Build();
Web.Data.Entities.Student student2 = new StudentBuilder().Build();
_section = new SectionBuilder().WithStudent(student1).WithStudent(student2).WithAssessment(_entity).Build();
_assessmentSection = _section.AssessmentSections.First();
}
private static void StudentsTask()
{
var students = new List <Student>();
var builder = new StudentBuilder();
while (true)
{
var student = builder
.SetFullName()
.SetPassedClasses()
.SetCategory()
.Build();
students.Add(student);
var key = Console.ReadKey(true);
if (key.Key == ConsoleKey.S)
{
break;
}
}
foreach (var student in students)
{
Console.WriteLine(student);
Console.WriteLine($"Is passed: {student.PassOffset()}");
}
}
public void NaoDeveCriarEstudanteComCPFInvalido(string InvalidCPF)
{
FluentActions.Invoking(() => StudentBuilder.New().WithCPF(InvalidCPF).Build())
.Should()
.Throw <DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidCPF));
}
public async Task ExcludeAllStudentsTestAsync()
{
var groupRepository = new FakeGroupRepository();
var group = await GroupBuilder.BuildAsync(groupRepository, 1);
var studentRepository = new FakeStudentRepository();
var student1 = await StudentBuilder.BuildAsync(studentRepository, 1);
var student2 = await StudentBuilder.BuildAsync(studentRepository, 2);
group.IncludeStudent(student1);
Assert.AreEqual(true, group.ExcludeAllStudents());
Assert.AreEqual(0, group.Grouping.Count);
group.IncludeStudent(student2);
Assert.AreEqual(true, group.ExcludeAllStudents());
Assert.AreEqual(0, group.Grouping.Count);
group.IncludeStudent(student1);
group.IncludeStudent(student2);
Assert.AreEqual(true, group.ExcludeAllStudents());
Assert.AreEqual(0, group.Grouping.Count);
Assert.AreEqual(false, group.ExcludeAllStudents());
Assert.AreEqual(0, group.Grouping.Count);
}
public async Task <Student> Update(string id, Person person)
{
try
{
var students = await _repository.Get(id);
var numara = students.Number;
if (students != null)
{
IStudentBuilder builder = new StudentBuilder(person);
builder.BuildMail();
builder.BuildClass();
builder.BuildNumber((int.Parse(numara.Substring(4, 7)) - 1));
_ = await _repository.Update(id, builder.Result());
NewStudentSystemController newStudentSystemController = new NewStudentSystemController(_repositoryNewStudentSystem);
_ = newStudentSystemController.Update(id, builder.Result());
}
return(students);
}
catch (Exception)
{
return(null);
}
}
private static void BuilderPattern()
{
HtmlBuilder hb = new HtmlBuilder("ul");
hb.AddChild("li", "Hello World from ul li");
Console.WriteLine(hb);
hb = new HtmlBuilder("p");
hb.AddChild("a", "Hello world from paragraph");
hb.AddChild("a", "Hello world from paragraph2");
hb.AddChild("li", "li tag").AddChild("li", "chaining in builder");
Console.WriteLine(hb);
//var builder = new PersonJobBuilder();
//builder.Called("Saba");
//.WorksAs
var emp = Employee
.New
.WorksAs("Developer")
.Called("Saba")
.Build();
Console.WriteLine(emp);
var sb = new StudentBuilder();
Student student = sb
.Studies.At("TSU")
.On("Exact and natural sciences")
.Is.Called("Saba");
Console.WriteLine();
}
public void DeveAlterarCPFDoEstudante()
{
var valorEsperado = _faker.Person.Cpf();
var student = StudentBuilder.New().Build();
student.UpdateCPF(valorEsperado);
student.CPF.Should().Be(valorEsperado);
}
public void DeveAlterarNomeDoEstudante()
{
var valorEsperado = _faker.Person.FullName;
var student = StudentBuilder.New().Build();
student.UpdateName(valorEsperado);
student.Name.Should().Be(valorEsperado);
}
public void DeveAlterarEmailDoEstudante()
{
var valorEsperado = _faker.Person.Email;
var student = StudentBuilder.New().Build();
student.UpdateEmail(valorEsperado);
student.Email.Should().Be(valorEsperado);
}
public void DeveAlterarPublicoAlvoDoEstudante()
{
var valorEsperado = _faker.PickRandom <TargetAudience>();
var student = StudentBuilder.New().Build();
student.UpdateTargetAudience(valorEsperado);
student.TargetAudience.Should().Be(valorEsperado);
}
public void NaoDeveAdicionarCursoComOMesmoNomeEIdDiferenteDoOutroSalvo()
{
var studentAlreadySaved = StudentBuilder.New().WithCPF(_studentDTO.CPF).WithId(60).Build();
_studentRepositoryMock.Setup(r => r.GetByCPF(_studentDTO.CPF)).Returns(studentAlreadySaved);
_studentDTO.Id = _faker.Random.Int(50, 100);
FluentActions.Invoking(() => _studentService.Save(_studentDTO)).Should().Throw <DomainException>().Where(d => d.ErrorMessages.Contains(Resource.CPFAlreadyExists));
}
public void NaoDevePublicoAlvoDeAlunoECursoSeremDiferentes()
{
var curso = CursoBuilder.Novo().ComPublicoAlvo(TargetAudience.Employee).Build();
var aluno = StudentBuilder.New().WithTargetAudience(TargetAudience.Graduate).Build();
Assert.Throws <DomainException>(() =>
MatriculaBuilder.Novo().ComAluno(aluno).ComCurso(curso).Build())
.ComMensagem(Resource.DifferentTargetAudience);
}
public void NaoDeveAlterarEstudanteComNomeInvalido(string InvalidName)
{
var student = StudentBuilder.New().Build();
FluentActions.Invoking(() => student.UpdateName(InvalidName))
.Should()
.Throw <DomainException>()
.Where(d => d.ErrorMessages.Contains(Resource.InvalidName));
}
public void ShouldMapWithDefaultValueIfNoProfilePhotoExists()
{
SetupWithDownloaderReturning("");
var student = new StudentBuilder().WithParent().Build();
var profileModel = _mapper.Build(student);
profileModel.ProfilePhotoUrl.ShouldBe("/Assets/Images/placeholder.png");
}
public void NaoDeveAdicionarAlunoQuandoCpfJaFoiCadastrado()
{
var studentWithSameNif = StudentBuilder.New().WithId(34).Build();
_studentRepository.Setup(r => r.GetByNif(_studentDto.Nif)).Returns(studentWithSameNif);
Assert.Throws <DomainException>(() => _studentStorer.Store(_studentDto))
.ComMensagem(Resource.AlreadyRegisteredNif);
}
public void DeveAlterarNome()
{
var novoNomeEsperado = _faker.Person.FullName;
var aluno = StudentBuilder.New().Build();
aluno.ChangeName(novoNomeEsperado);
Assert.Equal(novoNomeEsperado, aluno.Name);
}
public void ShouldNotCreateWithTargetAudienceIsDiferent()
{
var course = CourseBuilder.New().WithTargetAudience(TargetAudience.Employee).Build();
var student = StudentBuilder.New().WithTargetAudience(TargetAudience.Student).Build();
Assert.Throws <DomainException>(() =>
RegistrationBuilder.New().WithCourse(course).WithStudent(student).Build())
.WithMessage(Messages.TARGET_AUDIENCE_IS_DIFERENT_STUDENT_COURSE);
}
public void Run()
{
Student s1 = new StudentBuilder().name("Eli").build();
Student s2 = new StudentBuilder()
.name("Spicoli")
.age(16)
.motto("Aloha, Mr Hand")
.build();
}
public void ShouldMap()
{
var student = new StudentBuilder().WithFirstName("Hugo").WithLastSurname("Range").Build();
var gradeModel = new StudentToGradeModelMapper().Build(student);
gradeModel.StudentFirstName.ShouldBe(student.FirstName);
gradeModel.StudentLastName.ShouldBe(student.LastSurname);
gradeModel.StudentUSI.ShouldBe(student.StudentUSI);
}
public void AddsOneStudentToEmptyCourseSuccessfully()
{
_courseRepository.Setup(c => c.GetWithStudents(It.IsAny <long>())).Returns(new CourseBuilder().WithDefaultValues());
var serviceMock = new CourseStudentSignupService(_courseRepository.Object, _appLogger.Object, null);
var student = new StudentBuilder().WithDefaultValues();
serviceMock.Signup(It.IsAny <long>(), student.Name, student.Age);
}
public void ShouldChangeName()
{
var expectedName = _faker.Person.FullName;
var student = StudentBuilder.New().Build();
student.ChangeName(expectedName);
Assert.Equal(expectedName, student.Name);
}
public void ShouldSaveAndFetchStudent()
{
var student = new StudentBuilder().Build();
this.studentRepository.SaveOrUpdate(student);
this.FlushAndClearSession();
var studentRetrieved = this.studentRepository.GetById(student.Id);
Assert.IsNotNull(studentRetrieved);
Assert.That(studentRetrieved.Id, Is.Not.EqualTo(0));
}
static void Main(string[] args)
{
StudentBuilder sb = new StudentBuilder();
Student oneParameter = sb.WithName("Marie").Build();
Student twoParameter = sb.WithName("Jonh").WithAge(25).Build();
Student threeParameter = sb.WithName("Jonh").WithAge(25).WithBithdayDate(new DateTime()).Build();
Console.WriteLine($"oneParameter => {oneParameter}");
Console.WriteLine($"twoParameter => {twoParameter}");
Console.WriteLine($"threeParameter => {threeParameter}");
}
public void Post_AddStudentInvalidModelShallReturnBadRequest()
{
//Arrange
_controller.ModelState.AddModelError("StudentNames", "The name is required");
var studentToAdd = new StudentBuilder().WithEmptyName().Build();
//Act
var result = _controller.Post_AddStudent(studentToAdd) as BadRequestResult;
//Assert
Assert.That(result, Is.Not.Null);
}
public void Put_MismatchBetweenUrlIdAndStudentIdCausesBadRequest()
{
//Arange
var student = new StudentBuilder().WithId().Build();
//Act
var badRequestResult = _controller.Put(10, student) as BadRequestResult;
//Assert
Assert.That(badRequestResult, Is.Not.Null);
}
public void ShouldMapStudentToProfileModelWithoutAcademicDetails()
{
var student = new StudentBuilder().WithParent().Build();
SetupWithDownloaderReturning(null);
var profileModel = _mapper.Build(student);
NativeStudentPropertiesShouldBeMapped(student, profileModel);
profileModel.AcademicDetail.ShouldBe(null);
}
public void NaoDeveAdicionarQuandoForEdicao()
{
_studentDto.Id = 35;
var alunoJaSalvo = StudentBuilder.New().Build();
_studentRepository.Setup(r => r.GetById(_studentDto.Id)).Returns(alunoJaSalvo);
_studentStorer.Store(_studentDto);
_studentRepository.Verify(r => r.Add(It.IsAny <Student>()), Times.Never);
}
public void ShouldGenerateJoinDateByDefault()
{
var student = new StudentBuilder().Build();
studentRepository.SaveOrUpdate(student);
FlushAndClearSession();
var studentRetrievedRetrieved = studentRepository.GetById(student.Id);
Assert.IsNotNull(studentRetrievedRetrieved);
Assert.That(studentRetrievedRetrieved.JoinDate.Date, Is.EqualTo(DateTime.Now.Date));
}
public void ThrowsGivenFullCourseCapacity()
{
_courseRepository.Setup(c => c.GetWithStudents(It.IsAny <long>())).Returns(new CourseBuilder().WithFullCapacity());
var serviceMock = new CourseStudentSignupService(_courseRepository.Object, _appLogger.Object, null);
var student = new StudentBuilder().WithDefaultValues();
Assert.Throws <CourseIsFullException>(() =>
serviceMock.Signup(It.IsAny <long>(), student.Name, student.Age));
}
public void ShouldGenerateJoinDateByDefault()
{
var student = new StudentBuilder().Build();
studentRepository.SaveOrUpdate(student);
FlushAndClearSession();
var studentRetrievedRetrieved = studentRepository.GetById(student.Id);
Assert.IsNotNull(studentRetrievedRetrieved);
Assert.That(studentRetrievedRetrieved.JoinDate.Date, Is.EqualTo(DateTime.Now.Date));
}
public void DeveEditarNomeDoAluno()
{
_studentDto.Id = 35;
_studentDto.Name = _faker.Person.FullName;
var alunoJaSalvo = StudentBuilder.New().Build();
_studentRepository.Setup(r => r.GetById(_studentDto.Id)).Returns(alunoJaSalvo);
_studentStorer.Store(_studentDto);
Assert.Equal(_studentDto.Name, alunoJaSalvo.Name);
}
public void ShouldAddCommitAndDeleteStudent()
{
var student = new StudentBuilder().Build();
studentRepository.SaveOrUpdate(student);
studentRepository.CommitAndCloseSession();
studentRepository.Delete(student);
studentRepository.CommitAndCloseSession();
var studentRetrievedAfterDelete = studentRepository.GetById(student.Id);
Assert.IsNull(studentRetrievedAfterDelete);
}
public void ShouldCheckUniqueConstaintOfRollNumber()
{
var student1 = new StudentBuilder().WithRollNumber("12345").Build();
studentRepository.SaveOrUpdate(student1);
FlushAndClearSession();
var student2 = new StudentBuilder().WithRollNumber("12345").Build();
var exception = Assert.Catch(() => studentRepository.SaveOrUpdate(student2));
Assert.That(exception.InnerException.GetType(), Is.EqualTo(typeof(SqlException)));
Assert.That(exception.InnerException.Message.Contains("Violation of UNIQUE KEY constraint"));
}
public void ShouldMap()
{
var student = new StudentBuilder().Build();
var takeAttendanceModel = new TakeAttendanceModelBuilder().WithStudent(student).Build();
var section = new SectionBuilder().WithStudent(student).Build();
var mapper = new TakeAttendanceModelToStudentSectionAttendanceEventListMapper();
var studentSectionAttendanceEventList = mapper.Build(takeAttendanceModel, section).ToList();
studentSectionAttendanceEventList.First().StudentUSI.ShouldBe(student.StudentUSI);
studentSectionAttendanceEventList.First().Student.ShouldBe(student);
}
public void ShouldSaveFetchAndUpdateStudent()
{
var student = new StudentBuilder().Build();
studentRepository.SaveOrUpdate(student);
FlushAndClearSession();
var studentRetrievedAfterAdd = studentRepository.GetById(student.Id);
Assert.IsNotNull(studentRetrievedAfterAdd);
Assert.That(studentRetrievedAfterAdd.Id, Is.Not.EqualTo(0));
const string MiddleName = "B";
studentRetrievedAfterAdd.MiddleName = MiddleName;
studentRepository.SaveOrUpdate(studentRetrievedAfterAdd);
FlushAndClearSession();
var studentRetrievedAfterUpdate = studentRepository.GetById(student.Id);
Assert.IsNotNull(studentRetrievedAfterUpdate);
Assert.That(studentRetrievedAfterUpdate.Id, Is.EqualTo(studentRetrievedAfterAdd.Id));
Assert.That(studentRetrievedAfterUpdate.MiddleName, Is.EqualTo(MiddleName));
}
public void ShouldSaveAndFetchStudentWithDepartment()
{
var department = new DepartmentBuilder().Build();
var departmentRepository = new DepartmentRepository();
departmentRepository.SaveOrUpdate(department);
var student = new StudentBuilder().Build();
student.Department = department;
studentRepository.SaveOrUpdate(student);
FlushAndClearSession();
var studentRetrieved = studentRepository.GetById(student.Id);
Assert.IsNotNull(studentRetrieved);
Assert.That(studentRetrieved.Id, Is.Not.EqualTo(0));
Assert.That(studentRetrieved.Department, Is.Not.Null);
Assert.That(studentRetrieved.Department.Code, Is.EqualTo(department.Code));
}
