Example #1
0
        public static ValidationResult Validate(ResidentialListing residentialListing,
                                                string ruleSet = ResidentialListingValidator.NormalRuleSet)
        {
            var validator = new ResidentialListingValidator();

            return(string.IsNullOrWhiteSpace(ruleSet)
                ? validator.Validate(residentialListing)
                : validator.Validate(residentialListing, ruleSet: ruleSet));
        }
            public void GivenAnREAResidentialFileThatIsNotCurrent_Validate_ShouldNotHaveValidationErrors(string ruleSet, ResidentialListing listing, int expectedErrorCount)
            {
                // Arrange.
                var validator = new ResidentialListingValidator();

                // Act.
                var result = validator.Validate(listing, ruleSet: ruleSet);

                // Assert.
                result.Errors.Count.ShouldBe(expectedErrorCount);
            }
            public void GivenTheFileREAResidentialCurrentXml_Validate_ShouldNotHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing = CreateListing();

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.Count.ShouldBe(0);
            }
            public void GivenTheFileREAResidentialCurrentXml_Validate_ShouldNotHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = CreateListing();

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.Count.ShouldBe(0);
            }
            public void GivenTheFileREAResidentialOffMarketXmlAndTheMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = CreateListing("Sample Data\\Transmorgrifiers\\REA\\Residential\\REA-Residential-OffMarket.xml");

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.Count.ShouldBe(4);
            }
            public void GivenTheFileREAResidentialWithdrawnXml_Validate_ShouldNotHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = CreateListing("Sample Data\\Transmorgrifiers\\REA\\Residential\\REA-Residential-Withdrawn.xml");

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

                // Assert.
                result.Errors.Count.ShouldBe(0);
            }
            public void GivenTheFileREAResidentialCurrentXml_Validate_ShouldNotHaveValidationErrors(string ruleSet)
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = FakeData.FakeListings.CreateAFakeResidentialListing();

                // Act.
                var result = validator.Validate(listing, ruleSet: ruleSet);

                // Assert.
                result.Errors.Count.ShouldBe(0);
            }
            public void GivenTheFileREAResidentialOffMarketXml_Validate_ShouldNotHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = FakeResidentialListing(StatusType.Removed);

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

                // Assert.
                result.Errors.Count.ShouldBe(0);
            }
            public void GivenAListingWithAMissingSuburbAddressAndAMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing = CreateListing();
                listing.Address.Suburb = null;

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.ShouldContain(x => x.PropertyName == "Address.Suburb");
            }
            public void GivenAListingWithAStreetNumberButMissingStreetAndAMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing = CreateListing();
                listing.Address.Street = string.Empty;

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.ShouldContain(x => x.PropertyName == "Address.Street");
            }
            public void GivenAnIncompleteListingAndAMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();

                // Act.
                var result = validator.Validate(new ResidentialListing(),
                                                ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.ShouldNotBe(null);
                result.Errors.Count.ShouldBe(9);
            }
            public void GivenAnIncompleteListingAndAMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();

                // Act.
                var result = validator.Validate(new ResidentialListing(),
                    ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.ShouldNotBe(null);
                result.Errors.Count.ShouldBe(9);
            }
            public void GivenAListingWithAMissingSuburbAddressAndAMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = CreateListing();

                listing.Address.Suburb = null;

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.ShouldContain(x => x.PropertyName == "Address.Suburb");
            }
            public void GivenAListingWithAMissingAgentNameAndAMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = CreateListing();

                listing.Agents.First().Name = string.Empty;

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.ShouldContain(x => x.PropertyName == "Agents[0].Name");
            }
            public void GivenAListingWithAStreetNumberButMissingStreetAndAMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = CreateListing();

                listing.Address.Street = string.Empty;

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.ShouldContain(x => x.PropertyName == "Address.Street");
            }
            public void GivenAFewLinksThatAreUrisAndTheMinimumRuleSet_Validate_ShouldNotHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var links     = new List <string>
                {
                    "http://www.google.com",
                    "https://www.microsoft.com",
                    "https://www.github.com"
                };

                // Act & Assert.
                validator.ShouldNotHaveValidationErrorFor(listing => listing.Links,
                                                          links,
                                                          ResidentialListingValidator.MinimumRuleSet);
            }
        public static ValidationResult Validate(Listing listing, bool isTheMinimumDataToStoreAListing = true)
        {
            if (listing is ResidentialListing)
            {
                var validator = new ResidentialListingValidator();
                return(isTheMinimumDataToStoreAListing
                    ? validator.Validate(listing as ResidentialListing, ruleSet: ResidentialListingValidator.MinimumRuleSet)
                    : validator.Validate(listing as ResidentialListing));
            }

            if (listing is RentalListing)
            {
                var validator = new RentalListingValidator();
                return(isTheMinimumDataToStoreAListing
                    ? validator.Validate(listing as RentalListing, ruleSet: RentalListingValidator.MinimumRuleSet)
                    : validator.Validate(listing as RentalListing));
            }

            if (listing is RuralListing)
            {
                var validator = new RuralListingValidator();
                return(isTheMinimumDataToStoreAListing
                    ? validator.Validate(listing as RuralListing, ruleSet: RuralListingValidator.MinimumRuleSet)
                    : validator.Validate(listing as RuralListing));;
            }

            if (listing is LandListing)
            {
                var validator = new LandListingValidator();
                return(isTheMinimumDataToStoreAListing
                    ? validator.Validate(listing as LandListing, ruleSet: LandListingValidator.MinimumRuleSet)
                    : validator.Validate(listing as LandListing));
            }

            var errorMessage =
                string.Format(
                    "Tried to validate an unhandled Listing type: {0}. Only Residental, Rental, Rural and Land listing types are supported.",
                    listing.GetType());

            throw new Exception(errorMessage);
        }
        public static ValidationResult Validate(Listing listing, string ruleSet = null)
        {
            if (listing is ResidentialListing)
            {
                var validator = new ResidentialListingValidator();
                return(string.IsNullOrWhiteSpace(ruleSet)
                    ? validator.Validate(listing as ResidentialListing)
                    : validator.Validate(listing as ResidentialListing, ruleSet: RentalListingValidator.MinimumRuleSet));
            }

            if (listing is RentalListing)
            {
                var validator = new RentalListingValidator();
                return(string.IsNullOrWhiteSpace(ruleSet)
                    ? validator.Validate(listing as RentalListing)
                    : validator.Validate(listing as RentalListing, ruleSet: RentalListingValidator.MinimumRuleSet));
            }

            if (listing is RuralListing)
            {
                var validator = new RuralListingValidator();
                return(string.IsNullOrWhiteSpace(ruleSet)
                    ? validator.Validate(listing as RuralListing)
                    : validator.Validate(listing as RuralListing, ruleSet: RentalListingValidator.MinimumRuleSet));;
            }

            if (listing is LandListing)
            {
                var validator = new LandListingValidator();
                return(string.IsNullOrWhiteSpace(ruleSet)
                    ? validator.Validate(listing as LandListing)
                    : validator.Validate(listing as LandListing, ruleSet: RentalListingValidator.MinimumRuleSet));
            }

            var errorMessage =
                string.Format(
                    "Tried to validate an unhandled Listing type: {0}. Only Residental, Rental, Rural and Land listing types are supported.",
                    listing.GetType());

            throw new Exception(errorMessage);
        }
        public static ValidationResult Validate(Listing listing, bool isTheMinimumDataToStoreAListing = true)
        {
            if (listing is ResidentialListing)
            {
                var validator = new ResidentialListingValidator();
                return isTheMinimumDataToStoreAListing
                    ? validator.Validate(listing as ResidentialListing, ruleSet: ResidentialListingValidator.MinimumRuleSet)
                    : validator.Validate(listing as ResidentialListing);
            }

            if (listing is RentalListing)
            {
                var validator = new RentalListingValidator();
                return isTheMinimumDataToStoreAListing
                    ? validator.Validate(listing as RentalListing, ruleSet: RentalListingValidator.MinimumRuleSet)
                    : validator.Validate(listing as RentalListing);
            }

            if (listing is RuralListing)
            {
                var validator = new RuralListingValidator();
                return isTheMinimumDataToStoreAListing
                    ? validator.Validate(listing as RuralListing, ruleSet: RuralListingValidator.MinimumRuleSet)
                    : validator.Validate(listing as RuralListing);;
            }

            if (listing is LandListing)
            {
                var validator = new LandListingValidator();
                return isTheMinimumDataToStoreAListing
                    ? validator.Validate(listing as LandListing, ruleSet: LandListingValidator.MinimumRuleSet)
                    : validator.Validate(listing as LandListing);
            }

            var errorMessage =
                string.Format(
                    "Tried to validate an unhandled Listing type: {0}. Only Residental, Rental, Rural and Land listing types are supported.",
                    listing.GetType());
            throw new Exception(errorMessage);
        }
            [InlineData(ResidentialListingValidator.StrictRuleSet, 12)] // Normal + 1
            public void GivenAnIncompleteListingAndARuleSet_Validate_ShouldHaveValidationErrors(string ruleSet,
                                                                                                int numberOfErrors)
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing   = FakeData.FakeListings.CreateAFakeResidentialListing();

                listing.StatusType = StatusType.Available; // Need to be available to check for errors.

                listing.Id        = null;
                listing.UpdatedOn = DateTime.MinValue;
                listing.AgencyId  = null;
                listing.CreatedOn = DateTime.MinValue;
                listing.Agents.First().Name         = null;              // Not legit.
                listing.Images.First().Url          = null;              // Not legit.
                listing.FloorPlans.First().Url      = null;              // Not legit.
                listing.Videos.First().Url          = null;              // Not legit.
                listing.Inspections.First().OpensOn = DateTime.MinValue; // Not legit.
                listing.LandDetails.Area.Value = -1;                     // Not legit.

                // The sum of the 3 carparking properties can't exceed 255 (a byte).
                listing.Features.CarParking.Carports = 200;
                listing.Features.CarParking.Garages  = 200;

                listing.Links = new List <string>
                {
                    "http://aa.bb.cc/dd/ee?ff=ggg", // Legit.
                    "sdfdsfsdfdf"                   // Not legit.
                };

                // Act.
                var result = validator.Validate(listing, ruleSet: ruleSet);

                // Assert.
                result.ShouldNotBeNull();
                result.Errors.Count.ShouldBe(numberOfErrors);
            }
            public void GivenAListingWithAMissingAgentNameAndAMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing = CreateListing();
                listing.Agents.First().Name = string.Empty;

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.ShouldContain(x => x.PropertyName == "Agents[0].Name");
            }
 public ResidentialListingValidatorFacts()
 {
     _listingValidator = new ResidentialListingValidator();
 }
 public SimpleValidationFacts()
 {
     _validator = new ResidentialListingValidator();
 }
Example #24
0
 public ResidentialListingValidatorFacts()
 {
     _listingValidator = new ResidentialListingValidator();
 }
            public void GivenAFewLinksThatAreUrisButOneIsInvalidAndTheMinimumRuleSet_Validate_ShouldNotHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var links = new List<string>
                {
                    "http://www.google.com",
                    "https://www.microsoft.com",
                    "https://www.github.com",
                    "aaaaa"
                };

                // Act & Assert.
                validator.ShouldHaveValidationErrorFor(listing => listing.Links,
                    links,
                    ResidentialListingValidator.MinimumRuleSet);
            }
 public SimpleValidationFacts()
 {
     _validator = new ResidentialListingValidator();
 }
            public void GivenTheFileREAResidentialOffMarketXmlAndTheMinimumRuleSet_Validate_ShouldHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing = CreateListing("Sample Data\\Transmorgrifiers\\REA\\Residential\\REA-Residential-OffMarket.xml");

                // Act.
                var result = validator.Validate(listing, ruleSet: ResidentialListingValidator.MinimumRuleSet);

                // Assert.
                result.Errors.Count.ShouldBe(4);
            }
            public void GivenTheFileREAResidentialWithdrawnXml_Validate_ShouldNotHaveValidationErrors()
            {
                // Arrange.
                var validator = new ResidentialListingValidator();
                var listing = CreateListing("Sample Data\\Transmorgrifiers\\REA\\Residential\\REA-Residential-Withdrawn.xml");

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

                // Assert.
                result.Errors.Count.ShouldBe(0);
            }