Example #1
1
        public void ThenISeeStep(Table data)
        {
            var validations = data.ToValidationTable();
            var page = this.GetPageFromContext();

            var context = new ValidateItemAction.ValidateItemContext(validations);
            this.actionPipelineService.PerformAction<ValidateItemAction>(page, context).CheckResult();
        }
        public void TestToValidationTableWhenTableIsEmptyThrowsException()
        {
            var table = new Table("Field", "Rule", "Value");

            ExceptionHelper.SetupForException<ElementExecuteException>(
                () => table.ToValidationTable(),
                ex => Assert.AreEqual("The validation table must contain at least one validation row.", ex.Message));
        }
        public void TestToValidationTableWhenValueColumnIsMissingThrowsException()
        {
            var table = new Table("Field", "Rule");

            ExceptionHelper.SetupForException<ElementExecuteException>(
                () => table.ToValidationTable(),
                ex => Assert.AreEqual(InvalidColumnErrorMessage, ex.Message));
        }
Example #4
0
        public void GoToListItemWithCriteriaStep(string listName, Table criteriaTable)
        {
            var page = this.GetPageFromContext();
            var validationTable = criteriaTable.ToValidationTable();

            var context = new GetListItemByCriteriaAction.ListItemByCriteriaContext(listName.ToLookupKey(), validationTable);

            var item = this.actionPipelineService.PerformAction<GetListItemByCriteriaAction>(page, context)
                                                 .CheckResult<IPage>();

            this.UpdatePageContext(item);
        }
Example #5
0
        public void ThenISeeListStep(string fieldName, string rule, Table data)
        {
            if (data == null || data.RowCount == 0)
            {
                return;
            }

            ComparisonType comparisonType;
            switch (rule.ToLookupKey())
            {
                case "exists":
                case "contains":
                    comparisonType = ComparisonType.Contains;
                    break;

                case "doesnotexist":
                case "doesnotcontain":
                    comparisonType = ComparisonType.DoesNotContain;
                    break;

                case "startswith":
                    comparisonType = ComparisonType.StartsWith;
                    break;

                case "endswith":
                    comparisonType = ComparisonType.EndsWith;
                    break;
                case "equals":
                    comparisonType = ComparisonType.Equals;
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Rule type '{0}' is not supported.", rule));
            }

            var page = this.GetPageFromContext();
            var validations = data.ToValidationTable();

            var context = new ValidateListAction.ValidateListContext(fieldName.ToLookupKey(), comparisonType, validations);
            this.actionPipelineService.PerformAction<ValidateListAction>(page, context).CheckResult();
        }
        public void TestToValidationTableWhenTableIsPopulatedReturnsValidationTable()
        {
            var table = new Table("Field", "Rule", "Value");
            table.AddRow("My Column", "equals", "Foo");

            var validationTable = table.ToValidationTable();

            Assert.IsNotNull(validationTable);
            Assert.AreEqual(1, validationTable.ValidationCount);

            var item = validationTable.Validations.First();
            Assert.AreEqual("My Column", item.RawFieldName);
            Assert.AreEqual("Foo", item.RawComparisonValue);
            Assert.AreEqual("equals", item.RawComparisonType);
        }