public void ColumnDefinitionParserThrowsExceptionWhenPropertyNameDefinedMoreThanOnce()
{
// Arrange
var id = new ImportDefinition();
id.Columns.Add(new ColumnDefinition()
{
ColumnNumber = 0,
DataType = Enums.DataTypes.STRING,
PropertyName = "DuplicatePropertyName"
});
var s = "COLUMN 1 DuplicatePropertyName STRING";
// Act
try
{
ColumnDefinitionParser.Parse(s, id);
Assert.Fail("InvalidOperationException expected, not thrown");
}
catch (InvalidOperationException ex)
{
Assert.AreEqual("A column with the name 'DuplicatePropertyName' is defined more than once.",
ex.Message);
}
catch (Exception ex)
{
Assert.Fail("InvalidOperationException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
public void ColumnDefinitionParserThrowsExceptionWhenColumnNumberDefinedTwice()
{
// Arrange
var id = new ImportDefinition();
id.Columns.Add(new ColumnDefinition()
{
ColumnNumber = 0,
DataType = Enums.DataTypes.STRING,
PropertyName = "ColumnNameZero"
});
var s = "COLUMN 0 ColumnZeroAgain STRING";
try
{
ColumnDefinitionParser.Parse(s, id);
Assert.Fail("InvalidOperationException expected, not thrown.");
}
catch (InvalidOperationException ex)
{
Assert.AreEqual("A column with the number 0 is defined more than once.",
ex.Message);
}
catch (Exception ex)
{
Assert.Fail("InvalidOperationException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
public void ColumnDefinitionParserCreatesPRECISIONRule()
{
// Arrange
var s = "COLUMN 1 ColumnName DECIMAL PRECISION 6 3";
var id = new ImportDefinition();
// Act
ColumnDefinitionParser.Parse(s, id);
// Assert
Assert.AreEqual(1, id.Rules.Count);
var r = (DecimalPrecisionRule)id.Rules[0];
Assert.AreEqual("ColumnName", r.PropertyName);
Assert.AreEqual(6, r.PrecisionValue);
Assert.AreEqual(3, r.ScaleValue);
}
private void ColumnDefinitionParserCreatesColumn(Enums.DataTypes dataType)
{
// Arrange
var id = new ImportDefinition();
var s = "COLUMN 1 ColumnName " + dataType.ToString();
// Act
ColumnDefinitionParser.Parse(s, id);
// Assert
Assert.AreEqual(1, id.Columns.Count);
var c = id.Columns[0];
Assert.AreEqual(dataType, c.DataType);
Assert.AreEqual(1, c.ColumnNumber);
Assert.AreEqual("ColumnName", c.PropertyName);
}
public void ColumnDefinitionParserCreatesStringMaximumLengthRule()
{
// Arrange
var s = "COLUMN 1 ColumnName STRING MAXLENGTH 10";
var id = new ImportDefinition();
// Act
ColumnDefinitionParser.Parse(s, id);
// Assert
Assert.AreEqual(1, id.Rules.Count);
var r = (StringMaximumLengthRule)id.Rules[0];
Assert.AreEqual(typeof(StringMaximumLengthRule), r.GetType());
Assert.AreEqual("ColumnName", r.PropertyName);
Assert.IsTrue(r.Length.HasValue);
Assert.AreEqual(10, r.Length.Value);
}
public void ColumnDefinitionParserThrowsExceptionWhenImportDefinitionIsNull()
{
// Act
try
{
ColumnDefinitionParser.Parse("A Line", null);
Assert.Fail("Expected ArgumentNullException, not thrown.");
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("ID", ex.ParamName);
}
catch (Exception ex)
{
Assert.Fail("ArgumentNullException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
private static void ParseLine(string line, ImportDefinition id)
{
if (line.StartsWith("#"))
{
// This is a comment
return;
}
if (line.StartsWith("COLUMN"))
{
ColumnDefinitionParser.Parse(line, id);
return;
}
if (line.StartsWith("FILETYPE"))
{
FileTypeParser.Parse(line, id);
return;
}
else if (line.StartsWith("HEADERROW"))
{
HeaderRowParser.Parse(line, id);
return;
}
else if (line.StartsWith("TABLE"))
{
TableDefinitionParser.Parse(line, id);
return;
}
else if (line.StartsWith("RULE"))
{
RuleDefinitionParser.Parse(line, id);
return;
}
else if (line.StartsWith("DESTINATION"))
{
DestinationParser.Parse(line, id);
return;
}
else
{
throw new ArgumentException("Invalid token at beginning of line: " + line);
}
}
private void ColumnDefinitionParserThrowsExceptionWhenLineIsNullEquivalent(string line)
{
// Arrange
var id = new ImportDefinition();
// Act
try
{
ColumnDefinitionParser.Parse(line, id);
Assert.Fail("Expected ArgumentNullException, not thrown.");
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("Line", ex.ParamName);
}
catch (Exception ex)
{
Assert.Fail("ArgumentNullException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
public void ColumnDefinitionParserThrowsExceptionWhenExtraTokenIsInvalid()
{
// Arrange
var id = new ImportDefinition();
var s = "COLUMN 0 ColumnName STRING NOTAVALIDTOKEN";
// Act
try
{
ColumnDefinitionParser.Parse(s, id);
Assert.Fail("ArgumentException expected, not thrown.");
}
catch (ArgumentException ex)
{
Assert.AreEqual("Invalid token: NOTAVALIDTOKEN", ex.Message);
}
catch (Exception ex)
{
Assert.Fail("ArgumentException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
public void ColumnDefinitionParserCreatesRequiredRule()
{
// Arrange
var id = new ImportDefinition();
var s = "COLUMN 0 ColumnName STRING REQUIRED";
// Act
ColumnDefinitionParser.Parse(s, id);
// Assert
Assert.AreEqual(1, id.Columns.Count);
var c = id.Columns[0];
Assert.AreEqual(0, c.ColumnNumber);
Assert.AreEqual(Enums.DataTypes.STRING, c.DataType);
Assert.AreEqual("ColumnName", c.PropertyName);
Assert.AreEqual(1, id.Rules.Count);
var r = id.Rules[0];
Assert.AreEqual(typeof(RequiredRule), r.GetType());
Assert.AreEqual("ColumnName", r.PropertyName);
}
public void ColumnDefinitionParserThrowsExceptionWhenLineHasTooFewTokens()
{
// Arrange
var s = "COLUMN 1 PropertyName";
var id = new ImportDefinition();
// Act
try
{
ColumnDefinitionParser.Parse(s, id);
Assert.Fail("ArgumentException expected, not thrown.");
}
catch (ArgumentException ex)
{
Assert.AreEqual("Column definition line must contain at least 4 tokens.",
ex.Message);
}
catch (Exception ex)
{
Assert.Fail("ArgumentException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
public void ColumnDefinitionParserThrowsExceptionWhenLineIsNotColumnDeclaration()
{
// Arrange
var id = new ImportDefinition();
var s = "NOTACOLUMN 0 ColumnName";
// Act
try
{
ColumnDefinitionParser.Parse(s, id);
Assert.Fail("ArgumentException expected, not thrown.");
}
catch (ArgumentException ex)
{
Assert.AreEqual("Line is not a COLUMN declaration.",
ex.Message);
}
catch (Exception ex)
{
Assert.Fail("ArgumentException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
private void ColumnDefinitionParserThrowsExceptionOnPRECISIONDeclaredOnNonString(Enums.DataTypes dataType)
{
// Arrange
var id = new ImportDefinition();
var s = "COLUMN 0 ColumnName " + dataType.ToString() + " PRECISION 6 3";
// Act
try
{
ColumnDefinitionParser.Parse(s, id);
Assert.Fail("ArgumentException expected, not thrown.");
}
catch (ArgumentException ex)
{
Assert.AreEqual("PRECISION validation token can only be specified for data type DECIMAL.",
ex.Message);
}
catch (Exception ex)
{
Assert.Fail("Argument Exception expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
public void ColumnDefinitionParserThrowsExceptionWhenDataTypeIsInvalid()
{
// Arrange
var id = new ImportDefinition();
var s = "COLUMN 0 ColumnName INVALIDTYPE";
// Act
try
{
ColumnDefinitionParser.Parse(s, id);
Assert.Fail("InvalidCastException expected, not thrown.");
}
catch (InvalidCastException ex)
{
Assert.AreEqual("Cannot convert the token INVALIDTYPE to a valid DataType.",
ex.Message);
}
catch (Exception ex)
{
Assert.Fail("InvalidCastException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
public void ColumnDefinitionParserThrowsExceptionWhenColumnNumberIsNotANumber()
{
// Arrange
var s = "COLUMN NOTANUMBER ColumnName STRING";
var id = new ImportDefinition();
// Act
try
{
ColumnDefinitionParser.Parse(s, id);
Assert.Fail("InvalidCaseException expected, not thrown.");
}
catch (InvalidCastException ex)
{
Assert.AreEqual("Cannot convert the token NOTANUMBER to an integer value.",
ex.Message);
}
catch (Exception ex)
{
Assert.Fail("InvalidCastException expected, " +
ex.GetType().Name +
" thrown instead.");
}
}
