public void TestExecuteWithNullValidatorsCollection()
        {
            var fakeModel = new FakeValidationTargetModel();
            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            IEnumerable<ValidationResult> validationResults = target.Execute(fakeModel, null);

            // Expected exception
        }
        public void TestExecuteWithNullModel()
        {
            var validators = new List<ValidatorContainer<FakeValidationTargetModel>>();
            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            IEnumerable<ValidationResult> validationResults = target.Execute(null, validators);

            // Expected exception
        }
        public void TestExecuteTroughtEmptyValidatorsCollection()
        {
            var fakeModel = new FakeValidationTargetModel();
            var validators = new List<ValidatorContainer<FakeValidationTargetModel>>();
            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            IEnumerable<ValidationResult> validationResults = target.Execute(fakeModel, validators);

            Assert.IsNotNull(validationResults);
            Assert.IsFalse(validationResults.Any());
        }
        public void TestExecuteWithValidValidator()
        {
            var fakeModel = new FakeValidationTargetModel();
            var mockValidator = ValidatorExecutorTestHelper.CreateMockValidator(true, Guid.NewGuid());
            var validators = new List<ValidatorContainer<FakeValidationTargetModel>>
            {
                ValidatorExecutorTestHelper.CreateValidatorContainer(mockValidator.Object, 0)
            };
            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            IEnumerable<ValidationResult> validationResults = target.Execute(fakeModel, validators);

            Assert.IsNotNull(validationResults);
            var failedValidator = validationResults.SingleOrDefault();
            Assert.IsNotNull(failedValidator);
            Assert.IsTrue(failedValidator.IsValid());
            mockValidator.Verify();
        }
        public void TestExecuteWithTwoAsyncValidatorsInvalidValidatorWithHighPriority()
        {
            var fakeModel = new FakeValidationTargetModel();
            var failedValidatorId = Guid.NewGuid();
            var firstMockValidator = ValidatorExecutorTestHelper.CreateMockValidator(false, Guid.NewGuid());
            var secondMockValidator = ValidatorExecutorTestHelper.CreateMockValidator(false, failedValidatorId);
            var validators = new List<ValidatorContainer<FakeValidationTargetModel>>
            {
                ValidatorExecutorTestHelper.CreateValidatorContainer(firstMockValidator.Object, 1),
                ValidatorExecutorTestHelper.CreateValidatorContainer(secondMockValidator.Object, 0)
            };

            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            IEnumerable<ValidationResult> validationResults = target.ExecuteAsync(fakeModel, validators).Result;

            Assert.IsNotNull(validationResults);
            var failedValidator = validationResults.FirstOrDefault();
            Assert.IsNotNull(failedValidator);
            Assert.IsFalse(failedValidator.IsValid());
            Assert.AreEqual(failedValidatorId, failedValidator.Id);
            firstMockValidator.Verify();
            secondMockValidator.Verify();
        }
        public void TestExecuteAsyncWithNullCollection()
        {
            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            var validationResults = target.ExecuteAsync(new FakeValidationTargetModel(), null).Result;

            // expected exception.
        }
        public void TestExecuteAsyncWithNullModel()
        {
            var validators = new List<ValidatorContainer<FakeValidationTargetModel>>();
            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            var validationResults = target.ExecuteAsync(null, validators).Result;

            // expected exception.
        }
        public void TestExecuteAsyncWithEmptyValidatorsCollection()
        {
            var fakeModel = new FakeValidationTargetModel();
            var validators = new List<ValidatorContainer<FakeValidationTargetModel>>();
            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            var validationResults = target.ExecuteAsync(fakeModel, validators).Result;

            Assert.IsNotNull(validationResults);
            Assert.IsFalse(validationResults.Any());
        }
        public void TestExecuteAsyncWithFailedValidator()
        {
            var fakeModel = new FakeValidationTargetModel();
            var mockValidator = ValidatorExecutorTestHelper.CreateMockValidator(false, Guid.NewGuid());
            var validators = new List<ValidatorContainer<FakeValidationTargetModel>>
            {
                ValidatorExecutorTestHelper.CreateValidatorContainer(mockValidator.Object, 0)
            };
            var target = new PlainValidatorExecutor<FakeValidationTargetModel>();

            var validationResults = target.ExecuteAsync(fakeModel, validators).Result;

            Assert.IsNotNull(validationResults);
            var failedValidatorTask = validationResults.SingleOrDefault();
            Assert.IsNotNull(failedValidatorTask);
            var failedValidator = failedValidatorTask;
            Assert.IsNotNull(failedValidator);
            Assert.IsFalse(failedValidator.IsValid());
            mockValidator.Verify();
        }