public void IfThenClauseNegated()
{
// Arrange
var mockField = new Mock <IField>().Object;
var expr = new FieldExpression(mockField);
var pred = new ConstantClause(expr, ComparisonOperator.GTE, DBValue.Create(100));
var subseq = new ConstantClause(expr, ComparisonOperator.LTE, DBValue.Create(200));
var subseqNeg = new ConstantClause(expr, ComparisonOperator.GT, DBValue.Create(200));
var clause = Clause.IfThen(pred, subseq).Negation();
var mockBuilder = new Mock <IConstraintDeclBuilder>();
// Sequence
var sequence = mockBuilder.MakeSequence();
sequence.Add(builder => builder.StartClause());
sequence.Add(builder => builder.AddClause(subseqNeg.Matcher()));
sequence.Add(builder => builder.And());
sequence.Add(builder => builder.AddClause(pred.Matcher()));
sequence.Add(builder => builder.EndClause());
// Act
var fields = clause.GetDependentFields();
clause.AddDeclarationTo(mockBuilder.Object);
// Assert
fields.Should().BeEquivalentTo(new IField[] { mockField, mockField });
sequence.VerifyCompleted();
mockBuilder.VerifyNoOtherCalls();
}
[TestMethod] public void StringifyRegular()
{
// Arrange
var rawBool = true;
var rawInt = 89;
var rawFloat = -123.11106;
var rawDate = new DateTime(2016, 11, 03);
var boolValue = DBValue.Create(rawBool);
var intValue = DBValue.Create(rawInt);
var floatValue = DBValue.Create(rawFloat);
var dateValue = DBValue.Create(rawDate);
// Act
var rawBoolStr = rawBool.ToString();
var rawIntStr = rawInt.ToString();
var rawFloatStr = rawFloat.ToString();
var rawDateStr = rawDate.ToString();
var boolStr = boolValue.ToString();
var intStr = intValue.ToString();
var floatStr = floatValue.ToString();
var dateStr = dateValue.ToString();
// Assert
boolStr.Should().Be(rawBoolStr);
intStr.Should().Be(rawIntStr);
floatStr.Should().Be(rawFloatStr);
dateStr.Should().Be(rawDateStr);
}
[TestMethod] public void DecomposeWithMultipleSteps()
{
// Arrange
var v = 100;
var value0 = DBValue.Create(v);
var value1 = DBValue.Create(v * 10);
var mockExtractor = new Mock <IFieldExtractor>();
mockExtractor.Setup(e => e.ExpectedSource).Returns(typeof(string));
mockExtractor.Setup(e => e.FieldType).Returns(typeof(Exception));
mockExtractor.Setup(e => e.Execute(It.IsAny <string>())).Returns(v);
var mockDecomp0 = new Mock <IExtractionStep>();
mockDecomp0.Setup(d => d.ExpectedSource).Returns(typeof(Exception));
mockDecomp0.Setup(d => d.Execute(It.IsAny <int>())).Returns(new DBValue[] { value0 });
var mockDecomp1 = new Mock <IExtractionStep>();
mockDecomp1.Setup(d => d.ExpectedSource).Returns(typeof(Exception));
mockDecomp1.Setup(d => d.Execute(It.IsAny <int>())).Returns(new DBValue[] { value1, value0 });
var decomps = new IExtractionStep[] { mockDecomp0.Object, mockDecomp1.Object };
var step = new DecomposingExtractionStep(mockExtractor.Object, decomps);
var source = "Albany";
// Act
var values = step.Execute(source);
// Assert
mockExtractor.Verify(e => e.Execute(source), Times.Once);
mockDecomp0.Verify(d => d.Execute(v), Times.Once);
mockDecomp1.Verify(d => d.Execute(v), Times.Once);
values.Should().BeEquivalentTo(new DBValue[] { value0, value1, value0 });
}
[TestMethod] public void ExtractFromNull()
{
// Arrange
var v = 100;
var value = DBValue.Create(v);
var mockExtractor = new Mock <IFieldExtractor>();
mockExtractor.Setup(e => e.ExpectedSource).Returns(typeof(string));
mockExtractor.Setup(e => e.FieldType).Returns(typeof(Exception));
mockExtractor.Setup(e => e.Execute(null)).Returns(null);
var mockDecomp = new Mock <IExtractionStep>();
mockDecomp.Setup(d => d.ExpectedSource).Returns(typeof(Exception));
mockDecomp.Setup(d => d.Execute(It.IsAny <int>())).Returns(new DBValue[] { value, value });
mockDecomp.Setup(d => d.Execute(null)).Returns(new DBValue[] { DBValue.NULL, DBValue.NULL });
var decomps = new IExtractionStep[] { mockDecomp.Object };
var step = new DecomposingExtractionStep(mockExtractor.Object, decomps);
string?source = null;
// Act
var values = step.Execute(source);
// Assert
values.Should().BeEquivalentTo(new DBValue[] { DBValue.NULL, DBValue.NULL });
}
[TestMethod] public void CreateFromNull()
{
// Arrange
object?rawValue = null;
// Act
var value = DBValue.Create(rawValue);
// Assert
value.Should().Be(DBValue.NULL);
}
[TestMethod] public void StringValueFitsEnumeration()
{
// Arrange
var type = DBType.Enumeration;
var value = DBValue.Create("String");
// Act
var isInstance = value.IsInstanceOf(type);
// Assert
isInstance.Should().BeTrue();
}
[TestMethod] public void StringifyText()
{
// Arrange
var rawString = "Justin Millman";
var stringValue = DBValue.Create(rawString);
// Act
var expected = $"\"{rawString}\"";
var stringStr = stringValue.ToString();
// Assert
stringStr.Should().Be(expected);
}
[TestMethod] public void StringifyCharacter()
{
// Arrange
var rawChar = '&';
var charValue = DBValue.Create(rawChar);
// Act
var expected = $"'{rawChar}'";
var charStr = charValue.ToString();
// Assert
charStr.Should().Be(expected);
}
[TestMethod] public void CreateFromStringIndirectly()
{
// Arrange
var rawValue = "Kvasir";
var expectedType = DBType.Text;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromArrayFails()
{
// Arrange
var rawValue = new double[] { 1.1, 2.2, 3.3, 4.4, 5.5 };
// Act
Func <DBValue> action = () => DBValue.Create(rawValue);
// Assert
action.Should().ThrowExactly <ArgumentException>()
.WithAnyMessage()
.And
.ParamName.Should().NotBeNullOrEmpty();
}
[TestMethod] public void CreateFromEnumerationFails()
{
// Arrange
var rawValue = EnvironmentVariableTarget.Machine;
// Act
Func <DBValue> action = () => DBValue.Create(rawValue);
// Assert
action.Should().ThrowExactly <ArgumentException>()
.WithAnyMessage()
.And
.ParamName.Should().NotBeNullOrEmpty();
}
[TestMethod] public void CreateFromDecimalIndirectly()
{
// Arrange
var rawValue = (decimal)86.77;
var expectedType = DBType.Decimal;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromDoubleIndirectly()
{
// Arrange
var rawValue = -317.445;
var expectedType = DBType.Double;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromGuidIndirectly()
{
// Arrange
var rawValue = new Guid(0, 1, 1, new byte[] { 2, 3, 5, 8, 13, 21, 34, 55 });
var expectedType = DBType.Guid;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromDateTimeIndirectly()
{
// Arrange
var rawValue = new DateTime(1996, 02, 29);
var expectedType = DBType.DateTime;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromULongIndirectly()
{
// Arrange
var rawValue = 111110108ul;
var expectedType = DBType.UInt64;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromUShortIndirectly()
{
// Arrange
var rawValue = (ushort)102;
var expectedType = DBType.UInt16;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromBoolInirectly()
{
// Arrange
var rawValue = false;
var expectedType = DBType.Boolean;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void CreateFromFloatIndirectly()
{
// Arrange
var rawValue = -99.000102f;
var expectedType = DBType.Single;
// Act
var value = DBValue.Create(rawValue);
var matches = value.IsInstanceOf(expectedType);
// Assert
value.Datum.Should().Be(rawValue);
matches.Should().BeTrue();
}
[TestMethod] public void Construct()
{
// Arrange
var name = new FieldName("Population");
var dbType = DBType.Int32;
var nullability = IsNullable.No;
var defaultValue = Option.Some(DBValue.Create(100));
// Act
var field = new BasicField(name, dbType, nullability, defaultValue);
// Assert
field.Name.Should <FieldName>().Be(name);
field.DataType.Should().Be(dbType);
field.Nullability.Should().Be(nullability);
field.DefaultValue.Should().Be(defaultValue);
}
[TestMethod] public void CreateFromCollectionFails()
{
// Arrange
var rawValue = new List <char>()
{
'K', 'v', 'a', 's', 'i', 'r', '!'
};
// Act
Func <DBValue> action = () => DBValue.Create(rawValue);
// Assert
action.Should().ThrowExactly <ArgumentException>()
.WithAnyMessage()
.And
.ParamName.Should().NotBeNullOrEmpty();
}
[TestMethod] public void Construct()
{
// Arrange
var name = new FieldName("Continent");
var nullability = IsNullable.Yes;
var defaultValue = Option.Some(DBValue.Create(null));
var enums = new DBValue[] { DBValue.Create("Europe"), DBValue.Create("Asia"), DBValue.Create("Africa") };
// Act
var field = new EnumField(name, nullability, defaultValue, enums);
// Assert
field.Name.Should <FieldName>().Be(name);
field.DataType.Should().Be(DBType.Enumeration);
field.Nullability.Should().Be(nullability);
field.DefaultValue.Should().Be(defaultValue);
field.Enumerators.Should().BeEquivalentTo(enums);
}
/// <inheritdoc/>
public IReadOnlyList <DBValue> Execute(object?source)
{
Debug.Assert(source is null || source.GetType().IsInstanceOf(ExpectedSource));
if (source is null)
{
return(new DBValue[] { DBValue.NULL });
}
// If the source object is not null, then performing the extraction will produce the requisite primitive.
// However, this primitive itself may be null; this is no problem, as the converter will properly handle
// this and produce DBValue.NULL. The PrimitiveExtractionStep can only ever return a collection of size 1,
// so this heuristic is sufficient to satisfy all postconditions.
var extraction = extractor_.Execute(source);
var conversion = converter_.Convert(extraction);
return(new DBValue[] { DBValue.Create(conversion) });
}
[TestMethod] public void GenerateDeclarationWithoutDefault()
{
// Arrange
var name = new FieldName("Status");
var nullability = IsNullable.No;
var enums = new DBValue[] { DBValue.Create("Independent"), DBValue.Create("Colony") };
var mockBuilder = new Mock <IFieldDeclBuilder>();
var field = new EnumField(name, nullability, Option.None <DBValue>(), enums);
// Act
_ = field.GenerateSqlDeclaration(mockBuilder.Object);
// Assert
mockBuilder.Verify(builder => builder.SetName(name));
mockBuilder.Verify(builder => builder.SetDataType(DBType.Enumeration));
mockBuilder.Verify(builder => builder.SetNullability(nullability));
mockBuilder.Verify(builder => builder.SetAllowedValues(Arg.IsSameSequence <IEnumerable <DBValue> >(enums)));
mockBuilder.Verify(builder => builder.Build());
mockBuilder.VerifyNoOtherCalls();
}
public void ConstantClauseNotNegated()
{
// Arrange
var mockField = new Mock <IField>();
var expr = new FieldExpression(mockField.Object);
var op = ComparisonOperator.LT;
var value = DBValue.Create(100);
mockField.Setup(field => field.DataType).Returns(DBType.Int32);
// Act
var clause = new ConstantClause(expr, op, value);
var fields = clause.GetDependentFields();
// Assert
clause.LHS.Should().Be(expr);
clause.Operator.Should().Be(op);
clause.RHS.Should().Be(value);
fields.Should().BeEquivalentTo(new IField[] { mockField.Object });
}
public void InclusionClauseNotNegated()
{
// Arrange
var mockField = new Mock <IField>();
var expr = new FieldExpression(mockField.Object);
var op = InclusionOperator.In;
var values = new DBValue[] { DBValue.Create(100), DBValue.Create(200), DBValue.Create(300) };
mockField.Setup(field => field.DataType).Returns(DBType.Int32);
// Act
var clause = new InclusionClause(expr, op, values);
var fields = clause.GetDependentFields();
// Assert
clause.LHS.Should().Be(expr);
clause.Operator.Should().Be(op);
clause.RHS.Should().BeEquivalentTo(values);
fields.Should().BeEquivalentTo(new IField[] { mockField.Object });
}
[TestMethod] public void ExtractFromDerived()
{
// Arrange
var result = 10;
var mockExtractor = new Mock <IFieldExtractor>();
mockExtractor.Setup(e => e.ExpectedSource).Returns(typeof(Exception));
mockExtractor.Setup(e => e.FieldType).Returns(typeof(int));
mockExtractor.Setup(e => e.Execute(It.IsAny <Exception>())).Returns(result);
var conv = DataConverter.Identity <int>();
var step = new PrimitiveExtractionStep(mockExtractor.Object, conv);
var source = new NullReferenceException();
// Act
var value = step.Execute(source);
// Assert
mockExtractor.Verify(e => e.Execute(source), Times.Once);
value.Should().BeEquivalentTo(new DBValue[] { DBValue.Create(result) });
}
[TestMethod] public void ExtractWithNonIdentityConversion()
{
// Arrange
var result = 10;
var mockExtractor = new Mock <IFieldExtractor>();
mockExtractor.Setup(e => e.ExpectedSource).Returns(typeof(string));
mockExtractor.Setup(e => e.FieldType).Returns(typeof(int));
mockExtractor.Setup(e => e.Execute(It.IsAny <string>())).Returns(result);
var conv = DataConverter.Create <int, int>(i => i * 2);
var step = new PrimitiveExtractionStep(mockExtractor.Object, conv);
var source = "Detroit";
// Act
var value = step.Execute(source);
// Assert
mockExtractor.Verify(e => e.Execute(source), Times.Once);
value.Should().BeEquivalentTo(new DBValue[] { DBValue.Create(conv.Convert(result)) });
}
[TestMethod] public void Execute()
{
// Arrange
var year = DBValue.Create(2012);
var month = DBValue.Create(12);
var day = DBValue.Create(31);
var ymd = new Mock <IExtractionStep>();
ymd.Setup(e => e.ExpectedSource).Returns(typeof(DateTime));
ymd.Setup(e => e.Execute(It.IsAny <DateTime>())).Returns(new DBValue[] { year, month, day });
var hour = DBValue.Create(23);
var minute = DBValue.Create(59);
var second = DBValue.Create(59);
var hms = new Mock <IExtractionStep>();
hms.Setup(e => e.ExpectedSource).Returns(typeof(DateTime));
hms.Setup(e => e.Execute(It.IsAny <DateTime>())).Returns(new DBValue[] { hour, minute, second });
var offsetCnv = DataConverter.Create <int, int>(i => i - 1);
var identityCnv = DataConverter.Identity <int>();
var extractors = new IExtractionStep[] { ymd.Object, hms.Object };
var converters = Enumerable.Repeat(offsetCnv, 3).Concat(Enumerable.Repeat(identityCnv, 3));
var plan = new EntityExtractionPlan(extractors, converters);
var source = DateTime.Now;
// Act
var values = plan.Execute(source);
// Assert
values.Should().HaveCount(6);
values[0].Should().Be(DBValue.Create((int)year.Datum - 1));
values[1].Should().Be(DBValue.Create((int)month.Datum - 1));
values[2].Should().Be(DBValue.Create((int)day.Datum - 1));
values[3].Should().Be(hour);
values[4].Should().Be(minute);
values[5].Should().Be(second);
ymd.Verify(e => e.Execute(source));
hms.Verify(e => e.Execute(source));
}
[TestMethod] public void GenerateDeclarationWithDefault()
{
// Arrange
var name = new FieldName("GDP");
var dbType = DBType.UInt32;
var nullability = IsNullable.Yes;
var defaultValue = DBValue.Create(2500000u);
var field = new BasicField(name, dbType, nullability, Option.Some(defaultValue));
var mockBuilder = new Mock <IFieldDeclBuilder>();
// Act
_ = field.GenerateSqlDeclaration(mockBuilder.Object);
// Assert
mockBuilder.Verify(builder => builder.SetName(name));
mockBuilder.Verify(builder => builder.SetDataType(dbType));
mockBuilder.Verify(builder => builder.SetNullability(nullability));
mockBuilder.Verify(builder => builder.SetDefaultValue(defaultValue));
mockBuilder.Verify(builder => builder.Build());
mockBuilder.VerifyNoOtherCalls();
}
