public void CalculateValidationRuleDataTypeTest(FieldType fieldType)
{
// Arrange
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(fieldType)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
rules.Single().PropertyName.Should().Be(fieldType.ToString());
rules.Single().JsonName.Should().Be(fieldType.ToString());
rules.Single().IsDynamicField.Should().BeTrue();
rules.Single().Rules.Should().HaveCount(0);
}
public void AnalyseModelIsNullTest()
{
// Arrange
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
// Act
var result = _classUnderTest.Analyse(null, fieldInformation);
// Assert
result.Result.Should().HaveCount(1);
result.Result.ContainsKey(nameof(FieldType.Text) + "Assignment").Should().BeTrue();
}
public void CalculateValidationRuleNoRulesTest(FieldType fieldType)
{
// Arrange
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(fieldType)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(0);
}
public void AnalyseMissingFieldValueTest()
{
// Arrange
var alpha = new Alpha
{
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.TextMultiline, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result.ContainsKey(nameof(FieldType.Text) + "Assignment").Should().BeFalse();
}
public void AnalyseDuplicateAssignmentTest()
{
// Arrange
var alpha = new Alpha
{
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text),
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result[nameof(FieldType.Text) + "Assignment"].Id.Should().Be(nameof(FieldType.Text) + "Value");
result.Result[nameof(FieldType.Text) + "Assignment"].Value.Should().Be("Let's get dangerous");
result.Result[nameof(FieldType.Text) + "Assignment"].Type.Should().Be(typeof(string));
}
public void CalculateValidationRulesNotEqualsToDataRowTest(FieldType fieldType, string propertyValueName, object defaultValue)
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(fieldType, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "DarkwingDuck"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "LaunchpadMcQuack"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsDefault
}
};
typeof(DynamicFieldConfiguration).GetProperty(propertyValueName).SetValue(fieldDefinition.Configurations.Last(), defaultValue);
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
var rule = rules.Single();
rule.PropertyName.Should().Be(fieldType.ToString());
rule.JsonName.Should().Be(fieldType.ToString());
rule.IsDynamicField.Should().BeTrue();
rule.Rules.First(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("DarkwingDuck");
rule.Rules.First(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(defaultValue?.ToString());
rule.Rules.Last(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("LaunchpadMcQuack");
rule.Rules.Last(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(defaultValue?.ToString());
}
public void AnalyseInvalidFieldInformationTest()
{
// Arrange
var alpha = new Alpha
{
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
var fieldInformationNoDefinitions = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>(),
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = alpha.FieldValues
};
var fieldInformationNoAssignments = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>(),
Values = alpha.FieldValues
};
var fieldInformationNoFieldValues = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = new List <DynamicFieldValue>()
};
// Act
var resultNoDefinitions = _classUnderTest.Analyse(alpha, fieldInformationNoDefinitions);
var resultNoAssignments = _classUnderTest.Analyse(alpha, fieldInformationNoAssignments);
var resultNoFieldValues = _classUnderTest.Analyse(alpha, fieldInformationNoFieldValues);
// Assert
resultNoDefinitions.Result.Should().HaveCount(2);
resultNoAssignments.Result.Should().HaveCount(2);
resultNoFieldValues.Result.Should().HaveCount(2);
}
public void AnalyseValidationIgnoreTest()
{
// Arrange
var alpha = new Alpha
{
Beta = "Darkwing Duck",
Gamma = "MegaVolt",
Epsilon = new Alpha
{
Beta = "beta",
Gamma = "gamme",
Delta = new Omega
{
Stigma = 666
}
},
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text, nameof(DynamicFieldValue.ValueString), "Let's get dangerous")
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.Text)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result.Should().HaveCount(3);
result.Result.ContainsKey(nameof(FieldType.Text) + "Assignment").Should().BeTrue();
result.Result[nameof(Alpha.Beta)].Id.Should().Be(nameof(Alpha.Beta));
result.Result[nameof(Alpha.Beta)].Value.Should().Be(alpha.Beta);
result.Result[nameof(Alpha.Beta)].Type.Should().Be(typeof(string));
result.Result[nameof(Alpha.Gamma)].Id.Should().Be(nameof(Alpha.Gamma));
result.Result[nameof(Alpha.Gamma)].Value.Should().Be(alpha.Gamma);
result.Result[nameof(Alpha.Gamma)].Type.Should().Be(typeof(string));
}
public void CalculateValidationRulesEqualsToTest()
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(FieldType.Text, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.EqualsTo, ValueString = "DarkwingDuck"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.EqualsTo, ValueString = "LaunchpadMcQuack"
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
var rule = rules.Single();
rule.PropertyName.Should().Be(nameof(FieldType.Text));
rule.JsonName.Should().Be(nameof(FieldType.Text));
rule.IsDynamicField.Should().BeTrue();
rule.Rules.Should().HaveCount(2);
rule.Rules[0].Rule.Should().Be("EqualsTo");
rule.Rules[0].PropertyName.Should().Be("DarkwingDuck");
rule.Rules[1].Rule.Should().Be("EqualsTo");
rule.Rules[1].PropertyName.Should().Be("LaunchpadMcQuack");
}
public void CalculateValidationRulesRangeTest()
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(FieldType.NumberInteger, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.Minimum, ValueInteger = 5
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.Maximum, ValueInteger = 10
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.NumberInteger)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.NumberInteger)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
rules.Single().PropertyName.Should().Be("NumberInteger");
rules.Single().JsonName.Should().Be("NumberInteger");
rules.Single().IsDynamicField.Should().BeTrue();
rules.Single().Rules.Should().HaveCount(3);
rules.Single().Rules[0].Rule.Should().Be("Number");
rules.Single().Rules[1].Rule.Should().Be("DecimalPlaces");
rules.Single().Rules[1].Value.Should().Be(0);
rules.Single().Rules[2].Rule.Should().Be("Range");
rules.Single().Rules[2].Minimum.Should().Be(5);
rules.Single().Rules[2].Maximum.Should().Be(10);
}
public void CalculateValidationRulesStringLengthTest()
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(FieldType.Text, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.MinLength, ValueInteger = 5
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.MaxLength, ValueInteger = 10
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.Text)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.Text)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
rules.Single().PropertyName.Should().Be("Text");
rules.Single().JsonName.Should().Be("Text");
rules.Single().IsDynamicField.Should().BeTrue();
rules.Single().Rules.Should().HaveCount(2);
rules.Single().Rules.First().Rule.Should().Be("MinLength");
rules.Single().Rules.First().Value.Should().Be(5);
rules.Single().Rules.Last().Rule.Should().Be("MaxLength");
rules.Single().Rules.Last().Value.Should().Be(10);
}
public void AnalyseDataTypesDataRowTest(FieldType fieldType, string valuePropertyName, Type type, object value)
{
// Arrange
var alpha = new Alpha
{
Beta = "Darkwing Duck",
Gamma = "MegaVolt",
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType, valuePropertyName, value)
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(fieldType)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result.Should().HaveCount(3);
result.Result[nameof(Alpha.Beta)].Id.Should().Be(nameof(Alpha.Beta));
result.Result[nameof(Alpha.Beta)].Value.Should().Be(alpha.Beta);
result.Result[nameof(Alpha.Beta)].Type.Should().Be(typeof(string));
result.Result[nameof(Alpha.Gamma)].Id.Should().Be(nameof(Alpha.Gamma));
result.Result[nameof(Alpha.Gamma)].Value.Should().Be(alpha.Gamma);
result.Result[nameof(Alpha.Gamma)].Type.Should().Be(typeof(string));
result.Result[fieldType.ToString() + "Assignment"].Id.Should().Be(fieldType.ToString() + "Value");
result.Result[fieldType.ToString() + "Assignment"].Value.Should().Be(value);
result.Result[fieldType.ToString() + "Assignment"].Type.Should().Be(type);
}
public void CalculateValidationRuleDecimalPlacesTest(FieldType fieldType, int decimalPlaces)
{
// Arrange
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(fieldType, FieldConfigurationType.DecimalPlaces)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType)
}
};
fieldInformation.Definitions.Single().Configurations.Single().ValueInteger = decimalPlaces;
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(1);
rules.Single().DataType.Should().Be("number");
rules.Single().PropertyName.Should().Be(fieldType.ToString());
rules.Single().JsonName.Should().Be(fieldType.ToString());
rules.Single().IsDynamicField.Should().BeTrue();
rules.Single().Rules.Should().HaveCount(2);
rules.Single().Rules[0].Rule.Should().Be("Number");
rules.Single().Rules[1].Rule.Should().Be("DecimalPlaces");
rules.Single().Rules[1].Value.Should().Be(decimalPlaces);
}
public void CalculateValidationRulesNotEqualsToTest()
{
// Arrange
var guidOne = Guid.NewGuid();
var guidTwo = Guid.NewGuid();
var dateTime = DateTime.UtcNow;
var fieldDefinitionDecimal = ConfigurationHelper.CreateDefinition(FieldType.NumberDecimal, null);
fieldDefinitionDecimal.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "DarkwingDuck"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "LaunchpadMcQuack"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsDefault, ValueDecimal = 5m
}
};
var fieldDefinitionDateTime = ConfigurationHelper.CreateDefinition(FieldType.DateTime, null);
fieldDefinitionDateTime.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "DarkwingDuck"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "LaunchpadMcQuack"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsDefault, ValueDateTime = dateTime
}
};
var fieldDefinitionComboxBoxGuid = ConfigurationHelper.CreateDefinition(FieldType.ComboxBoxGuid, null);
fieldDefinitionComboxBoxGuid.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "DarkwingDuck"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "LaunchpadMcQuack"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsDefault, ValueGuid = guidOne
}
};
var fieldDefinitionGuid = ConfigurationHelper.CreateDefinition(FieldType.Guid, null);
fieldDefinitionGuid.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "DarkwingDuck"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsTo, ValueString = "LaunchpadMcQuack"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.NotEqualsDefault, ValueGuid = guidTwo
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
fieldDefinitionDecimal,
fieldDefinitionDateTime,
fieldDefinitionComboxBoxGuid,
fieldDefinitionGuid
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.NumberDecimal),
ConfigurationHelper.CreateAssignment(FieldType.DateTime),
ConfigurationHelper.CreateAssignment(FieldType.ComboxBoxGuid),
ConfigurationHelper.CreateAssignment(FieldType.Guid)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.NumberDecimal),
ConfigurationHelper.CreateField(FieldType.DateTime),
ConfigurationHelper.CreateField(FieldType.ComboxBoxGuid),
ConfigurationHelper.CreateField(FieldType.Guid)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(4);
var ruleDecimal = rules.Single(r => r.PropertyName == nameof(FieldType.NumberDecimal));
ruleDecimal.JsonName.Should().Be(nameof(FieldType.NumberDecimal));
ruleDecimal.IsDynamicField.Should().BeTrue();
ruleDecimal.Rules.First(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("DarkwingDuck");
ruleDecimal.Rules.First(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(5m.ToString(CultureInfo.InvariantCulture));
ruleDecimal.Rules.Last(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("LaunchpadMcQuack");
ruleDecimal.Rules.Last(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(5m.ToString(CultureInfo.InvariantCulture));
var ruleDateTime = rules.Single(r => r.PropertyName == nameof(FieldType.DateTime));
ruleDateTime.JsonName.Should().Be(nameof(FieldType.DateTime));
ruleDateTime.IsDynamicField.Should().BeTrue();
ruleDateTime.Rules.First(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("DarkwingDuck");
ruleDateTime.Rules.First(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(dateTime.ToString("yyyy-MM-ddTHH:mm:ss"));
ruleDateTime.Rules.Last(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("LaunchpadMcQuack");
ruleDateTime.Rules.Last(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(dateTime.ToString("yyyy-MM-ddTHH:mm:ss"));
var ruleComboxBoxGuid = rules.Single(r => r.PropertyName == nameof(FieldType.ComboxBoxGuid));
ruleComboxBoxGuid.JsonName.Should().Be(nameof(FieldType.ComboxBoxGuid));
ruleComboxBoxGuid.IsDynamicField.Should().BeTrue();
ruleComboxBoxGuid.Rules.First(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("DarkwingDuck");
ruleComboxBoxGuid.Rules.First(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(guidOne.ToString());
ruleComboxBoxGuid.Rules.Last(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("LaunchpadMcQuack");
ruleComboxBoxGuid.Rules.Last(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(guidOne.ToString());
var ruleGuid = rules.Single(r => r.PropertyName == nameof(FieldType.Guid));
ruleGuid.JsonName.Should().Be(nameof(FieldType.Guid));
ruleGuid.IsDynamicField.Should().BeTrue();
ruleGuid.Rules.First(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("DarkwingDuck");
ruleGuid.Rules.First(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(guidTwo.ToString());
ruleGuid.Rules.Last(r => r.Rule == "NotEqualsTo").PropertyName.Should().Be("LaunchpadMcQuack");
ruleGuid.Rules.Last(r => r.Rule == "NotEqualsTo").DefaultValue.Should().Be(guidTwo.ToString());
}
public void CalculateValidationRulesRangeBetweenTest(FieldType fieldType)
{
// Arrange
var fieldDefinition = ConfigurationHelper.CreateDefinition(fieldType, null);
fieldDefinition.Configurations = new List <DynamicFieldConfiguration>
{
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.RangeBetween
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.RangeBetweenFrom, ValueString = fieldType.ToString() + "ValueFrom"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.RangeBetweenTo, ValueString = fieldType.ToString() + "ValueTo"
},
new DynamicFieldConfiguration {
ConfigurationType = FieldConfigurationType.AllowNull
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(fieldType, null, "From"),
ConfigurationHelper.CreateDefinition(fieldType, null, "To"),
fieldDefinition
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(fieldType, "From"),
ConfigurationHelper.CreateAssignment(fieldType, "To"),
ConfigurationHelper.CreateAssignment(fieldType)
},
Values = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(fieldType, "From"),
ConfigurationHelper.CreateField(fieldType, "To"),
ConfigurationHelper.CreateField(fieldType)
}
};
// Act
var rules = _classUnderTest.CalculateValidationRules(fieldInformation);
// Assert
rules.Should().HaveCount(3);
var ruleFrom = rules.Last();
ruleFrom.PropertyName.Should().Be(fieldType.ToString());
ruleFrom.JsonName.Should().Be(fieldType.ToString());
ruleFrom.IsDynamicField.Should().BeTrue();
ruleFrom.Rules.Should().HaveCount(3);
ruleFrom.Rules[0].Rule.Should().Be("Number");
ruleFrom.Rules[1].Rule.Should().Be("DecimalPlaces");
ruleFrom.Rules[1].Value.Should().Be(0);
ruleFrom.Rules[2].Rule.Should().Be("RangeBetween");
ruleFrom.Rules[2].PropertyNameFrom.Should().Be(fieldType.ToString() + "ValueFrom");
ruleFrom.Rules[2].PropertyNameTo.Should().Be(fieldType.ToString() + "ValueTo");
ruleFrom.Rules[2].PropertyNameFromAllowNull.Should().BeTrue();
ruleFrom.Rules[2].PropertyNameToAllowNull.Should().BeTrue();
}
public void AnalyseDataTypesTest()
{
// Arrange
var guidOne = Guid.NewGuid();
var guidTwo = Guid.NewGuid();
var alpha = new Alpha
{
Beta = "Darkwing Duck",
Gamma = "MegaVolt",
FieldValues = new List <DynamicFieldValue>
{
ConfigurationHelper.CreateField(FieldType.NumberDecimal, nameof(DynamicFieldValue.ValueDecimal), 3.5m),
ConfigurationHelper.CreateField(FieldType.DateTime, nameof(DynamicFieldValue.ValueDateTime), DateTime.Today),
ConfigurationHelper.CreateField(FieldType.Guid, nameof(DynamicFieldValue.ValueGuid), guidOne),
ConfigurationHelper.CreateField(FieldType.ComboxBoxGuid, nameof(DynamicFieldValue.ValueGuid), guidTwo)
}
};
var fieldInformation = new FieldInformation <DynamicFieldDefinition, DynamicFieldAssignment, DynamicFieldValue, string, int>
{
Definitions = new List <DynamicFieldDefinition>
{
ConfigurationHelper.CreateDefinition(FieldType.NumberDecimal),
ConfigurationHelper.CreateDefinition(FieldType.DateTime),
ConfigurationHelper.CreateDefinition(FieldType.Guid),
ConfigurationHelper.CreateDefinition(FieldType.ComboxBoxGuid)
},
Assignments = new List <DynamicFieldAssignment>
{
ConfigurationHelper.CreateAssignment(FieldType.NumberDecimal),
ConfigurationHelper.CreateAssignment(FieldType.DateTime),
ConfigurationHelper.CreateAssignment(FieldType.Guid),
ConfigurationHelper.CreateAssignment(FieldType.ComboxBoxGuid)
},
Values = alpha.FieldValues
};
// Act
var result = _classUnderTest.Analyse(alpha, fieldInformation);
// Assert
result.Result.Should().HaveCount(6);
result.Result[nameof(Alpha.Beta)].Id.Should().Be(nameof(Alpha.Beta));
result.Result[nameof(Alpha.Beta)].Value.Should().Be(alpha.Beta);
result.Result[nameof(Alpha.Beta)].Type.Should().Be(typeof(string));
result.Result[nameof(Alpha.Gamma)].Id.Should().Be(nameof(Alpha.Gamma));
result.Result[nameof(Alpha.Gamma)].Value.Should().Be(alpha.Gamma);
result.Result[nameof(Alpha.Gamma)].Type.Should().Be(typeof(string));
result.Result[nameof(FieldType.NumberDecimal) + "Assignment"].Id.Should().Be(nameof(FieldType.NumberDecimal) + "Value");
result.Result[nameof(FieldType.NumberDecimal) + "Assignment"].Value.Should().Be(3.5m);
result.Result[nameof(FieldType.NumberDecimal) + "Assignment"].Type.Should().Be(typeof(decimal));
result.Result[nameof(FieldType.DateTime) + "Assignment"].Id.Should().Be(nameof(FieldType.DateTime) + "Value");
result.Result[nameof(FieldType.DateTime) + "Assignment"].Value.Should().Be(DateTime.Today);
result.Result[nameof(FieldType.DateTime) + "Assignment"].Type.Should().Be(typeof(DateTime));
result.Result[nameof(FieldType.Guid) + "Assignment"].Id.Should().Be(nameof(FieldType.Guid) + "Value");
result.Result[nameof(FieldType.Guid) + "Assignment"].Value.Should().Be(guidOne);
result.Result[nameof(FieldType.Guid) + "Assignment"].Type.Should().Be(typeof(Guid));
result.Result[nameof(FieldType.ComboxBoxGuid) + "Assignment"].Id.Should().Be(nameof(FieldType.ComboxBoxGuid) + "Value");
result.Result[nameof(FieldType.ComboxBoxGuid) + "Assignment"].Value.Should().Be(guidTwo);
result.Result[nameof(FieldType.ComboxBoxGuid) + "Assignment"].Type.Should().Be(typeof(Guid));
}
