public void CastIntString(int value, bool allowCast, bool throwCastException, bool result, bool expectException)
{
EqualSpecification specification = new EqualSpecification("key", SpecificationValue.AnyOf("1", "2"));
SpecificationEvaluationSettings settings =
new SpecificationEvaluationSettings
{
IncludeDetails = true,
ThrowValueErrors = throwCastException
};
settings.ValueSettings.AllowCast = allowCast;
Dictionary <string, object> values = new Dictionary <string, object> {
{ "key", value }
};
if (expectException)
{
Assert.Throws <InvalidOperationException>(() => specification.Evaluate(values, settings));
}
else
{
var res = specification.Evaluate(values, settings);
Assert.Equal(result, res.IsSatisfied);
}
}
public void DoSomthing()
{
Specification specification =
new AndSpecification(new EqualSpecification("key1", SpecificationValue.Single("value1")), new
OrSpecification(
new HasValueSpecification("key2"),
new EqualSpecification("key5", SpecificationValue.Single(new DateTime(2018, 10, 10, 1, 2, 3, DateTimeKind.Local))),
// value of key3 should be equal to any of values 1,2,3
new EqualSpecification("key3", SpecificationValue.AnyOf(1, 2, 3))),
// key4 should be greater or equal to value with name "currentDateTime" which will be resolved at specification evaluation
new GreaterOrEqualSpecification("key4", SpecificationValue.Ref("currentDateTime")));
Dictionary <string, object> values = new Dictionary <string, object>
{
{ "key1", "value1" },
{ "key3", 1 },
{ "key4", DateTime.Now.AddMinutes(1) },
// value referenced from specification
{ "currentDateTime", DateTime.UtcNow }
};
SpecificationResult result = specification.Evaluate(values);
Assert.True(result.IsSatisfied);
string xml = specification.ToXml();
Console.WriteLine(xml);
Specification sp2 = Specification.Parse.FromXml(XElement.Parse(xml));
}
protected SpecificationResult Compare(
SpecificationValue left,
SpecificationValue rigth,
SpecificationEvaluationSettings settings)
{
if (left.ValueType != rigth.ValueType)
{
List <object> cast = new List <object>();
foreach (object leftValue in left.Values)
{
if (TypeHelper.HasMappingOrCast(leftValue, rigth.ValueType, settings.ValueSettings, out object leftCast))
{
cast.Add(leftCast);
}
else
{
if (settings.ThrowValueErrors)
{
throw new InvalidOperationException(
string.Format(
SpecAbsRes.KeyValueSpecificationTypeNotMatch,
left.ValueType,
this.Key,
this.Value.ValueType));
}
return(SpecificationResult.Create(
false,
settings.IncludeDetails
? string.Format(
SpecAbsRes.KeyValueSpecificationTypeNotMatch,
left.ValueType,
this.Key,
rigth.ValueType)
: null));
}
}
if (left.Values.Count == 1)
{
left = SpecificationValue.Single(cast.Single());
}
if (left.ValueMultiplicity == SpecificationValue.Multiplicity.AnyOf)
{
left = SpecificationValue.AnyOf(cast);
}
else if (left.ValueMultiplicity == SpecificationValue.Multiplicity.AllOf)
{
left = SpecificationValue.AllOf(cast);
}
else
{
throw new InvalidOperationException();
}
}
return(this.CompareSafeTypes(left, rigth, settings));
}
public void AnyOfInt()
{
SpecificationValue value = SpecificationValue.AnyOf(1, 2, 4);
Assert.NotNull(value);
Assert.Collection(value.Values.OfType <int>(), i => Assert.Equal(1, i), i => Assert.Equal(2, i), i => Assert.Equal(4, i));
Assert.Equal(SpecificationValue.Multiplicity.AnyOf, value.ValueMultiplicity);
Assert.Equal(SpecificationValue.DataType.Int, value.ValueType);
Assert.Equal("Any of (1, 2, 4)", value.ToString());
}
public void SingleAny(int l, int r1, int r2, bool result)
{
EqualSpecification specification = new EqualSpecification(
"key",
SpecificationValue.AnyOf(new List <int> {
r1, r2
}));
Assert.Equal(result, specification.Evaluate(new Dictionary <string, object> {
{ "key", l }
}).IsSatisfied);
Assert.Equal(
result,
specification.Evaluate(new Dictionary <string, object> {
{ "key", SpecificationValue.Single(l) }
})
.IsSatisfied);
}
public void AnyAll(int l1, int l2, int r1, int r2, bool result)
{
EqualSpecification specification = new EqualSpecification("key", SpecificationValue.AllOf(r1, r2));
Assert.Equal(
result,
specification.Evaluate(new Dictionary <string, object> {
{ "key", new List <int> {
l1, l2
} }
})
.IsSatisfied);
Assert.Equal(
result,
specification.Evaluate(new Dictionary <string, object> {
{ "key", SpecificationValue.AnyOf(l1, l2) }
})
.IsSatisfied);
}
public void ReplaceMultivalueSpecification()
{
EqualSpecification equal = new EqualSpecification(
"k1",
SpecificationValue.Ref("{p1}"));
ValueReferenceVisitor visitor = new ValueReferenceVisitor(
new Dictionary <string, object> {
{ "{p1}", SpecificationValue.AnyOf("v1", "v2") }
});
Specification result = visitor.Visit(equal);
var r = Assert.IsType <EqualSpecification>(result);
Assert.NotSame(equal, r);
Assert.Contains("v1", r.Value.Values);
Assert.Contains("v2", r.Value.Values);
Assert.DoesNotContain("{p1}", r.Value.Values);
Assert.Equal(equal.Key, r.Key);
Assert.Equal(SpecificationValue.Multiplicity.AnyOf, r.Value.ValueMultiplicity);
Assert.Equal(SpecificationValue.DataType.String, r.Value.ValueType);
}
public void CastIntArrayString(
int value,
bool allowCast,
bool throwCastException,
bool result,
bool expectException)
{
EqualSpecification specification = new EqualSpecification("key", SpecificationValue.AnyOf("1", "2"));
SpecificationEvaluationSettings settings =
new SpecificationEvaluationSettings
{
IncludeDetails = true,
ThrowValueErrors = throwCastException
};
settings.ValueSettings.AllowCast = allowCast;
Dictionary <string, object> values =
new Dictionary <string, object> {
{ "key", new List <int> {
value, 123
} }
};
if (expectException)
{
var ae = Assert.Throws <InvalidOperationException>(() => specification.Evaluate(values, settings));
Assert.Contains("can't be compared with type", ae.Message);
}
else
{
var res = specification.Evaluate(values, settings);
Assert.Equal(result, res.IsSatisfied);
}
}
public void CastUnsupportedType()
{
EqualSpecification specification = new EqualSpecification("key", SpecificationValue.AnyOf("1", "2"));
Dictionary <string, object> values =
new Dictionary <string, object> {
{ "key", new List <TimeSpan> {
TimeSpan.FromDays(1)
} }
};
var ae = Assert.Throws <InvalidOperationException>(() => specification.Evaluate(values));
Assert.Contains("Unable to resolve left value", ae.Message);
}
public void AnyOfNullValue()
{
Assert.Throws <ArgumentException>(() => SpecificationValue.AnyOf(new object[] { null }));
}
public void AnyOfMultipleTypes()
{
Assert.Throws <ArgumentException>(() => SpecificationValue.AnyOf(new object[] { 1, "qwe" }));
}
public void AnyOfZero()
{
Assert.Throws <ArgumentException>(() => SpecificationValue.AnyOf(new int[0]));
}
public void AnyOfNull()
{
Assert.Throws <ArgumentNullException>(() => SpecificationValue.AnyOf((IEnumerable <string>)null));
}
