コード例 #1
0
        public void GetById_ShouldGetStudent()
        {
            var fakeRepo = new FakeStudentRepository();

            var student1 = new Student()
            {
                StudentId = 1,
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5
            };

            var student2 = new Student()
            {
                StudentId = 2,
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5
            };

            fakeRepo.Add(student2);
            fakeRepo.Add(student1);

            var server = new InMemoryHttpServer <Student>("http://localhost/", fakeRepo);

            var response = server.CreateGetRequest("api/students/1");

            Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
            Assert.IsNotNull(response.Content);
        }
コード例 #2
0
        public void Should_Return_Error_When_Email_Exists()
        {
            var studentRepository = new FakeStudentRepository();
            var emailService      = new FakeEmailService();
            var handler           = new SubscriptionHandler(studentRepository, emailService);
            var command           = new CreateBoletoSubscriptionCommand
            {
                FirstName         = "Iago João",
                LastName          = "Peixoto",
                Document          = "45608646088",
                Email             = "*****@*****.**",
                BarCode           = "",
                BoletoNumber      = "",
                PaymentNumber     = "",
                PaidDate          = DateTime.Now,
                ExpireDate        = DateTime.Now.AddMonths(1),
                Total             = 60,
                TotalPaid         = 60,
                Payer             = "Iago João Peixoto",
                PayerDocument     = "45608646088",
                PayerDocumentType = EDocumentType.CPF,
                PayerEmail        = "*****@*****.**",
                PayerStreet       = "Beco Acioly",
                PayerNumber       = "413",
                PayerNeighborhood = "São Vicente de Paula",
                PayerCity         = "Parintins",
                PayerState        = "AM",
                PayerCountry      = "Brasil",
                PayerZipCode      = "69153421"
            };

            handler.Handle(command);
            Assert.AreEqual(false, handler.Valid);
        }
コード例 #3
0
        public void DeleteStudent_ShouldDeleteStudent()
        {
            Student studentEnitity = new Student()
            {
                StudentId = 1,
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5
            };

            var fakeRepo = new FakeStudentRepository();

            fakeRepo.Add(studentEnitity);
            fakeRepo.Add(studentEnitity);
            var controller = new StudentsController(fakeRepo);

            studentEnitity.FirstName = "Kiro";

            SetupController(controller);
            controller.PutStudent(studentEnitity.StudentId, studentEnitity);

            controller.DeleteStudent(studentEnitity.StudentId);

            Assert.AreEqual(1, fakeRepo.Entities.Count());
        }
コード例 #4
0
        public void Find_ShouldReturnOneStudent()
        {
            Mark markEntity = new Mark()
            {
                Subject = "Math",
                Value   = 5
            };

            var marks = new List <Mark>();

            marks.Add(markEntity);

            Student studentEnitity = new Student()
            {
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5,
                Marks     = marks
            };

            var fakeRepo = new FakeStudentRepository();

            fakeRepo.Add(studentEnitity);
            var controller = new StudentsController(fakeRepo);

            SetupController(controller);
            var students = controller.Find("Math", 5);

            Assert.IsNotNull(students);
            Assert.AreEqual(1, students.Count());
        }
コード例 #5
0
        public void Update_ShouldUpdateStudent()
        {
            Student studentEnitity = new Student()
            {
                StudentId = 1,
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5
            };

            var fakeRepo = new FakeStudentRepository();

            fakeRepo.Add(studentEnitity);
            fakeRepo.Add(studentEnitity);
            var controller = new StudentsController(fakeRepo);

            studentEnitity.FirstName = "Kiro";

            SetupController(controller);
            controller.PutStudent(studentEnitity.StudentId, studentEnitity);

            var student = controller.Get(studentEnitity.StudentId);

            Assert.IsNotNull(student);
            Assert.AreEqual("Kiro", student.FirstName);
        }
コード例 #6
0
        public void ShouldReturnErrorWhenDocumentExists()
        {
            var emailService      = new FakeEmailService();
            var studentRepository = new FakeStudentRepository();
            var handler           = new SubscriptionHandle(studentRepository, emailService);

            var command = new CreateBoletoSubscriptionCommand();

            command.FirstName         = "Tony";
            command.LastName          = "Stark";
            command.Document          = "99999999999";
            command.Email             = "*****@*****.**";
            command.BoletoNumber      = "1324254342";
            command.BarCode           = "1234456245";
            command.PaymentNumber     = "3134324";
            command.PaidDate          = DateTime.Now;
            command.ExpireDate        = DateTime.Now.AddMonths(1);
            command.Total             = 60;
            command.TotalPaid         = 60;
            command.Payer             = "Empresas Stark";
            command.PayerDocument     = "12345678910";
            command.PayerDocumentType = EDocumentType.CPF;
            command.PayerEmail        = "*****@*****.**";
            command.Street            = "rua teste";
            command.City    = "cidade teste";
            command.State   = "estado teste";
            command.Country = "USA";
            command.ZipCode = "877659870";

            handler.Handle(command);

            Assert.AreEqual(false, handler.Valid);
        }
コード例 #7
0
        public SubscriptionHandlerTests()
        {
            _mockEmailService      = new FakeEmailService();
            _mockStudentRepository = new FakeStudentRepository();

            _boletoCommand = new CreateBoletoSubscriptionCommand
            {
                BarCode           = "1234567890123",
                BoletoNumber      = "111",
                City              = "Curitiba",
                Country           = "Brasil",
                Document          = "99999999999",
                Email             = "*****@*****.**",
                ExpireDate        = DateTime.Now.AddDays(1),
                FirstName         = "Bruce",
                LastName          = "Wayne",
                Neighborhood      = "Gotham",
                PaidDate          = DateTime.Now,
                Payer             = "Alfred",
                PayerDocument     = "88888888888",
                PayerDocumentType = Domain.Enums.EDocumentType.CPF,
                PayerEmail        = "*****@*****.**",
                PaymentNumber     = "987654321",
                State             = "PR",
                Street            = "Rua Top",
                StreetNumber      = "666",
                Total             = 60,
                TotalPaid         = 60,
                ZipCode           = "88888-777"
            };
        }
コード例 #8
0
        public async Task SetFirstnameTestAsync()
        {
            // No valid value
            {
                var repository = new FakeStudentRepository();
                var validator  = new DefaultStudentValidator(new StudentValidationService(repository));
                var student    = await Student.BuildAsync(validator,
                                                          ValidSexId,
                                                          NotValidFirstname,
                                                          ValidMiddlename,
                                                          ValidLastname,
                                                          ValidCallsign);

                Assert.AreEqual(null, student.Firstname);
            }

            // Valid value
            {
                var repository = new FakeStudentRepository();
                var validator  = new DefaultStudentValidator(new StudentValidationService(repository));
                var student    = await Student.BuildAsync(validator,
                                                          ValidSexId,
                                                          ValidFirstname,
                                                          ValidMiddlename,
                                                          ValidLastname,
                                                          ValidCallsign);

                Assert.AreEqual(ValidFirstname, student.Firstname);
            }
        }
コード例 #9
0
ファイル: GroupTests.cs プロジェクト: ch3l/Velvetech
        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);
        }
コード例 #10
0
        public void TestQueryStudent()
        {
            var studentRepository = new FakeStudentRepository();
            var expr     = StudentQueries.GetStudent("34843436801");
            var result   = studentRepository.GetStudents(expr);
            var expected = 1;
            var actual   = result.Count();

            Assert.AreEqual(expected, actual);
        }
コード例 #11
0
        public void PostStudent_WhenStudentIsNull_StudentShouldnotBeAdded()
        {
            var fakeRepo   = new FakeStudentRepository();
            var controller = new StudentsController(fakeRepo);

            Student studentEnitity = null;

            SetupController(controller);
            controller.PostStudent(studentEnitity);

            Assert.AreEqual(0, fakeRepo.Entities.Count);
        }
コード例 #12
0
        public void GetAllStudentsTest()
        {
            var repository = new FakeStudentRepository();
            var school = new TownSchool { Name = "School", Location = "Town" };
            var student = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
            repository.entities.Add(student);
            var server = new InMemoryHttpServer("http://localhost/");

            var response = server.CreateGetRequest("api/students");

            Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
            Assert.IsNotNull(response.Content);
        }
コード例 #13
0
        public void GetStudentInvalidTest()
        {
            var repository = new FakeStudentRepository();
            var school = new TownSchool { Name = "School", Location = "Town" };
            var firstStudent = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
            var secondStudent = new Student { FirstName = "Peter", LastName = "Petrov", Age = 15, Grade = 9, TownSchool = school };
            repository.entities.Add(firstStudent);
            repository.entities.Add(secondStudent);
            var server = new InMemoryHttpServer("http://localhost/");

            var response = server.CreateGetRequest("api/students/3");

            Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
        }
コード例 #14
0
        public void SexIdTest()
        {
            const string propertyName = nameof(StudentValidator.SexId);
            const int    min          = SexIdMin;
            const int    max          = SexIdMax;

            var repository = new FakeStudentRepository();

            // Check less than min
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = min - 1;
                validator.SexId(value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                var error  = ValidationsTestHelper.CheckErrorType <ComparisonValidationError <int> >(errors);
                Assert.AreEqual(ComparisonResultType.Less, error.ComparisonResult);
                Assert.AreEqual(min, error.ComparisonValue);
            }

            // Check is min
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = min;
                validator.SexId(value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);
            }

            // Check is max
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = max;
                validator.SexId(value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);
            }

            // Check bigger than max
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = max + 1;
                validator.SexId(value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                var error  = ValidationsTestHelper.CheckErrorType <ComparisonValidationError <int> >(errors);
                Assert.AreEqual(ComparisonResultType.More, error.ComparisonResult);
                Assert.AreEqual(max, error.ComparisonValue);
            }
        }
コード例 #15
0
        public void GetAllSeveralStudentsControllerTest()
        {
            var repository = new FakeStudentRepository();
            var school = new TownSchool { Name = "School", Location = "Town" };
            var firstStudent = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
            var secondStudent = new Student { FirstName = "Peter", LastName = "Petrov", Age = 15, Grade = 9, TownSchool = school };
            var thirdStudent = new Student { FirstName = "Todor", LastName = "Todorov", Age = 7, Grade = 1, TownSchool = school };

            repository.entities.Add(firstStudent);
            repository.entities.Add(secondStudent);
            repository.entities.Add(thirdStudent);
            var controller = new StudentsController(repository);
            var studentsModels = controller.GetAll();

            Assert.IsTrue(studentsModels.Count() == 3);
        }
コード例 #16
0
        public void GetAllStudentsControllerTest()
        {
            var repository = new FakeStudentRepository();
            var school = new TownSchool { Name = "School", Location = "Town" };
            var student = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };

            repository.entities.Add(student);
            var controller = new StudentsController(repository);
            var studentsModels = controller.GetAll();

            Assert.IsTrue(studentsModels.Count() == 1);
            Assert.AreEqual(student.FirstName, studentsModels.First().FirstName);
            Assert.AreEqual(student.LastName, studentsModels.First().LastName);
            Assert.AreEqual(student.Age, studentsModels.First().Age);
            Assert.AreEqual(student.Grade, studentsModels.First().Grade);
        }
コード例 #17
0
        public void DeleteStudentsControllerTest()
        {
            var repository = new FakeStudentRepository();
            var school = new TownSchool { Name = "School", Location = "Town" };
            var firstStudent = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
            var secondStudent = new Student { FirstName = "Peter", LastName = "Petrov", Age = 15, Grade = 9, TownSchool = school };
            var thirdStudent = new Student { FirstName = "Todor", LastName = "Todorov", Age = 7, Grade = 1, TownSchool = school };

            var controller = new StudentsController(repository);
            var firstStudentModel = controller.Post(firstStudent);
            var secondStudentModel = controller.Post(secondStudent);
            var thirdStudentModel = controller.Post(thirdStudent);
            controller.Delete(3);

            Assert.IsTrue(controller.GetAll().Count() == 2);
            Assert.IsTrue(controller.GetAll().Count(x => x.FirstName == thirdStudent.FirstName) == 0);
        }
コード例 #18
0
        public void Validate_WhenStudentIsValid_ReturnsTrue()
        {
            //Arrange
            var fakeRepo = new FakeStudentRepository();

            fakeRepo.HasRegistered = true;

            var validator = new StudentValidator(fakeRepo);
            var student   = new Student();

            student.Age = 20;

            //Act
            var result = validator.Validate(student);

            //Assert
            Assert.IsTrue(result);
        }
コード例 #19
0
        public void GetStudentBySubjectMarkTest()
        {
            var repository = new FakeStudentRepository();
            var school = new TownSchool { Name = "School", Location = "Town" };
            var firstStudent = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
            var secondStudent = new Student { FirstName = "Peter", LastName = "Petrov", Age = 15, Grade = 9, TownSchool = school };
            firstStudent.Marks.Add(new Mark { Subject = "Math", Value = 5, Student = firstStudent });
            secondStudent.Marks.Add(new Mark { Subject = "History", Value = 4, Student = secondStudent });
            secondStudent.Marks.Add(new Mark { Subject = "IT", Value = 6, Student = secondStudent });
            repository.entities.Add(firstStudent);
            repository.entities.Add(secondStudent);
            var server = new InMemoryHttpServer("http://localhost/");

            var response = server.CreateGetRequest("api/students?subject=Math&value=5");

            Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
            Assert.IsNotNull(response.Content);
        }
コード例 #20
0
        public void PostStudent_WhenStudentIsValid_StudentShouldBeAdded()
        {
            var fakeRepo   = new FakeStudentRepository();
            var controller = new StudentsController(fakeRepo);

            Student studentEnitity = new Student()
            {
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5
            };

            SetupController(controller);
            controller.PostStudent(studentEnitity);

            Assert.AreEqual(1, fakeRepo.Entities.Count);
        }
コード例 #21
0
        public void PostStudent_WhenValidStudent_ShouldReturnStatusCode201()
        {
            var fakeRepo = new FakeStudentRepository();

            var server =
                new InMemoryHttpServer <Student>("http://localhost/", fakeRepo);

            var response = server.CreatePostRequest("api/students",
                                                    new Student()
            {
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5
            });

            Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
        }
コード例 #22
0
        public void GetByIdStudentsControllerTest()
        {
            var repository = new FakeStudentRepository();

            var school = new TownSchool { Name = "School", Location = "Town" };
            var firstStudent = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };
            var secondStudent = new Student { FirstName = "Peter", LastName = "Petrov", Age = 15, Grade = 9, TownSchool = school };
            var thirdStudent = new Student { FirstName = "Todor", LastName = "Todorov", Age = 7, Grade = 1, TownSchool = school };

            repository.entities.Add(firstStudent);
            repository.entities.Add(secondStudent);
            repository.entities.Add(thirdStudent);
            var controller = new StudentsController(repository);
            var studentModel = controller.Get(1);

            Assert.AreEqual(secondStudent.FirstName, studentModel.FirstName);
            Assert.AreEqual(secondStudent.LastName, studentModel.LastName);
            Assert.AreEqual(secondStudent.Age, studentModel.Age);
            Assert.AreEqual(secondStudent.Grade, studentModel.Grade);
        }
コード例 #23
0
        public async Task ExcludeFromAllGroupsTestAsync()
        {
            Assert.Fail("Has to be in integration tests");

            var groupRepository   = new FakeGroupRepository();
            var studentRepository = new FakeStudentRepository();

            var group1 = await GroupBuilder.BuildAsync(groupRepository, 1);

            var group2 = await GroupBuilder.BuildAsync(groupRepository, 2);

            var student = await StudentBuilder.BuildAsync(studentRepository, 1);

            group1.IncludeStudent(student);
            group2.IncludeStudent(student);

            Assert.AreEqual(true, student.ExcludeFromAllGroups());
            Assert.AreEqual(0, group1.Grouping.Count);
            Assert.AreEqual(0, group2.Grouping.Count);
        }
コード例 #24
0
        public void GetById_ShouldGetStudent()
        {
            Student studentEnitity = new Student()
            {
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5
            };

            var fakeRepo = new FakeStudentRepository();

            fakeRepo.Entities.Add(studentEnitity);
            fakeRepo.Entities.Add(studentEnitity);
            var controller = new StudentsController(fakeRepo);

            SetupController(controller);
            var student = controller.Get(1);

            Assert.IsNotNull(student);
        }
コード例 #25
0
        public void GetAll_WhenOneStudent_ShouldReturnStatusCode200AndNotNullContent()
        {
            var fakeRepo = new FakeStudentRepository();

            var student = new Student()
            {
                FirstName = "Minko",
                LastName  = "Markov",
                School    = new School(),
                Grade     = 5
            };

            fakeRepo.Add(student);

            var server = new InMemoryHttpServer <Student>("http://localhost/", fakeRepo);

            var response = server.CreateGetRequest("api/students");

            Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
            Assert.IsNotNull(response.Content);
        }
コード例 #26
0
        public void FirstnameTest()
        {
            const string propertyName  = nameof(StudentValidator.Firstname);
            const int    upperBoundary = FirstnameUpperBoundary;

            var repository = new FakeStudentRepository();

            // Check for null
            {
                var    validator = new DefaultStudentValidator(new StudentValidationService(repository));
                string value     = null;
                validator.Firstname(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <NullValidationError>(errors);
            }

            // Check is empty
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = "";
                validator.Firstname(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <EmptyValidationError <IEnumerable <char> > >(errors);
            }

            // Whitespaces check without boundary crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, upperBoundary).Select(x => ' ').ToArray());
                validator.Firstname(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <WhitespacesValidationError>(errors);
            }

            // Whitespaces check with boundary crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, upperBoundary + 1).Select(x => ' ').ToArray());
                validator.Firstname(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <WhitespacesValidationError>(errors);
            }

            // Upper boundary check without crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, upperBoundary).Select(x => 'x').ToArray());
                validator.Firstname(ref value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);
            }

            // Upper boundary check with crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, upperBoundary + 1).Select(x => 'x').ToArray());
                validator.Firstname(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <LengthComparisonValidationError>(errors);
                ValidationsTestHelper.CheckUpperBoundaryCross(
                    (LengthComparisonValidationError)validator.Errors[propertyName][0],
                    upperBoundary);
            }
        }
コード例 #27
0
        public async Task CallsignTestAsync()
        {
            const string propertyName  = nameof(StudentValidator.Callsign);
            const int    lowerBoundary = CallsignLowerBoundary;
            const int    upperBoundary = CallsignUpperBoundary;

            var repository = new FakeStudentRepository();

            // Check for null
            {
                var    validator = new DefaultStudentValidator(new StudentValidationService(repository));
                string value     = null;
                validator.Callsign(ref value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);
            }

            // Check is empty
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = "";
                validator.Callsign(ref value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);
            }

            // Whitespaces check without boundary crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, upperBoundary).Select(x => ' ').ToArray());
                validator.Callsign(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <WhitespacesValidationError>(errors);
            }

            // Whitespaces check with boundary crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, upperBoundary + 1).Select(x => ' ').ToArray());
                validator.Callsign(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <WhitespacesValidationError>(errors);
            }

            // Lower boundary check without crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, lowerBoundary).Select(x => 'x').ToArray());
                validator.Callsign(ref value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);
            }

            // Lower boundary check with crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, lowerBoundary - 1).Select(x => 'x').ToArray());
                validator.Callsign(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <LengthComparisonValidationError>(errors);
                ValidationsTestHelper.CheckLowerBoundaryCross(
                    (LengthComparisonValidationError)validator.Errors[propertyName][0],
                    lowerBoundary);
            }

            // Upper boundary check without crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, upperBoundary).Select(x => 'x').ToArray());
                validator.Callsign(ref value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);
            }

            // Upper boundary check with crossing
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));
                var value     = new string(Enumerable.Range(1, upperBoundary + 1).Select(x => 'x').ToArray());
                validator.Callsign(ref value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <LengthComparisonValidationError>(errors);
                ValidationsTestHelper.CheckUpperBoundaryCross(
                    (LengthComparisonValidationError)validator.Errors[propertyName][0],
                    upperBoundary);
            }

            // Check for uniqueness
            {
                var validator = new DefaultStudentValidator(new StudentValidationService(repository));

                string value = null;
                await validator.CallsignUniqueness(value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);

                value = new string(Enumerable.Range(1, lowerBoundary).Select(x => 'x').ToArray());
                await validator.CallsignUniqueness(value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 0);

                var student = await Student.BuildAsync(validator, 1, "firstname", "middlename", "lastname", value);

                await repository.AddAsync(student);

                await validator.CallsignUniqueness(value);

                var errors = ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <UniquenessValidationError <string> >(errors);

                value = null;
                await validator.CallsignUniqueness(value);

                ValidationsTestHelper.CheckErrorsCount(validator, propertyName, 1);
                ValidationsTestHelper.CheckErrorType <UniquenessValidationError <string> >(errors);
            }
        }
コード例 #28
0
        public void PostStudentsControllerTest()
        {
            var repository = new FakeStudentRepository();
            var school = new TownSchool { Name = "School", Location = "Town" };
            var student = new Student { FirstName = "Ivan", LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };

            var controller = new StudentsController(repository);
            var studentModel = controller.Post(student).Content.ReadAsStringAsync().Result;
            Student studentDeserialized = JsonConvert.DeserializeObject<Student>(studentModel);

            Assert.IsTrue(controller.GetAll().Count() == 1);
            Assert.IsNotNull(studentDeserialized);
            Assert.AreEqual(student.FirstName, studentDeserialized.FirstName);
            Assert.AreEqual(student.LastName, studentDeserialized.LastName);
            Assert.AreEqual(student.Age, studentDeserialized.Age);
            Assert.AreEqual(student.Grade, studentDeserialized.Grade);
        }
コード例 #29
0
 public IndexModel(FakeStudentRepository repo)
 {
     Repo     = repo;
     Students = Repo.GetStudents();
 }
コード例 #30
0
 public void TestInitialize()
 {
     _StudentRepository = new FakeStudentRepository();
 }
コード例 #31
0
        public void PostStudentInvalidNameTest()
        {
            var repository = new FakeStudentRepository();
            var school = new TownSchool { Name = "School", Location = "Town" };
            var student = new Student { FirstName = null, LastName = "Ivanov", Age = 9, Grade = 4, TownSchool = school };

            var server = new InMemoryHttpServer("http://localhost/");

            var response = server.CreatePostRequest("api/students", student);

            Assert.AreEqual(HttpStatusCode.InternalServerError, response.StatusCode);
        }