public void CrashesIfInvalidExpression()
{
const string url = "http://localhost:8080/test/";
var objectClass = new ObjectClassMock(1, "testtable");
QaValidUrls test = null;
using (var webServer = new WebServer(SendHeadResponse, url))
{
webServer.Run();
try
{
test = new QaValidUrls(objectClass, "blah(blah)");
Assert.Fail("Exception expected for invalid expression");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
}
Assert.IsNull(test);
}
public void CanHandleSpecialFieldValuesForUrls()
{
const string urlFieldName = "URL";
var objectClass = new ObjectClassMock(1, "testtable");
objectClass.AddField(urlFieldName, esriFieldType.esriFieldTypeString);
int urlFieldIndex = objectClass.FindField(urlFieldName);
Assert.IsTrue(urlFieldIndex >= 0);
IObject rowWithEmptyValue = CreateRow(objectClass, 1, urlFieldIndex, string.Empty);
IObject rowWithNullValue = CreateRow(objectClass, 2, urlFieldIndex, null);
IObject rowWithBlanksOnlyValue = CreateRow(objectClass, 3, urlFieldIndex, " ");
var errorCount = 0;
using (
var webServer = new WebServer(SendHeadResponse,
"http://localhost:8080/doesnotmatter/"))
{
webServer.Run();
var test = new QaValidUrls(objectClass, urlFieldName);
var runner = new QaTestRunner(test);
errorCount += runner.Execute(rowWithEmptyValue);
errorCount += runner.Execute(rowWithNullValue);
errorCount += runner.Execute(rowWithBlanksOnlyValue);
}
Assert.AreEqual(0, errorCount);
Assert.AreEqual(0, _webRequestCounts);
}
public void CanCheckOnlyDistinctUrls()
{
const string urlRoot = "http://localhost:8080/";
const string urlInfixExisting = "test/";
const string existingPrefix = urlRoot + urlInfixExisting;
const string helloWorldHtml = "hello_world.html";
const string urlFieldName = "URL_SUFFIX";
var objectClass = new ObjectClassMock(1, "testtable");
objectClass.AddField(FieldUtils.CreateTextField(urlFieldName, 500));
int urlFieldIndex = objectClass.FindField(urlFieldName);
Assert.IsTrue(urlFieldIndex >= 0);
IObject rowWithExistingUrl = CreateRow(objectClass, 1, urlFieldIndex,
helloWorldHtml);
string urlExpression = $"'{existingPrefix}' + [{urlFieldName}]";
var errorCount = 0;
using (var webServer = new WebServer(SendHeadResponse, existingPrefix))
{
webServer.Run();
var test = new QaValidUrls(objectClass, urlExpression);
var runner = new QaTestRunner(test);
errorCount += runner.Execute(rowWithExistingUrl);
errorCount += runner.Execute(rowWithExistingUrl);
errorCount += runner.Execute(rowWithExistingUrl);
}
Assert.AreEqual(0, errorCount);
Assert.AreEqual(1, _webRequestCounts);
}
public void CrashesIfUnexistingField()
{
const string url = "http://localhost:8080/test/";
var objectClass = new ObjectClassMock(1, "testtable");
QaValidUrls test = null;
using (var webServer = new WebServer(SendHeadResponse, url))
{
webServer.Run();
try
{
test = new QaValidUrls(objectClass, "doesnotexist");
Assert.Fail("Exception expected for non-existing field");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
}
Assert.IsNull(test);
}
public void CanUseCaseSensitivityForSimpleCondition()
{
const string textFieldName = "TextField";
const string value = "aaa";
int textFieldIndex;
ObjectClassMock objectClass = CreateObjectClass(textFieldName, out textFieldIndex);
IObject rowUpperCase = CreateRow(objectClass, 1, textFieldIndex, value.ToUpper());
IObject rowLowerCase = CreateRow(objectClass, 2, textFieldIndex, value.ToLower());
string constraint = string.Format("{0} = '{1}'", textFieldName, value.ToUpper());
var caseSensitiveTest = new QaConstraint(objectClass, constraint);
caseSensitiveTest.SetSqlCaseSensitivity(0, true);
var caseSensitiveRunner = new QaTestRunner(caseSensitiveTest);
Assert.AreEqual(0, caseSensitiveRunner.Execute(rowUpperCase));
Assert.AreEqual(1, caseSensitiveRunner.Execute(rowLowerCase)); // incorrect case
Assert.AreEqual(
"testtable,2: TEXTFIELD = 'aaa' [Constraints.ConstraintNotFulfilled] {TextField}",
caseSensitiveRunner.Errors[0].ToString());
caseSensitiveRunner.ClearErrors();
var caseInsensitiveTest = new QaConstraint(objectClass, constraint);
var caseInsensitiveRunner = new QaTestRunner(caseInsensitiveTest);
Assert.AreEqual(0, caseInsensitiveRunner.Execute(rowUpperCase));
Assert.AreEqual(0, caseInsensitiveRunner.Execute(rowLowerCase));
}
public static ITable GetMockTable()
{
var workspaceMock = new WorkspaceMock();
var result = new ObjectClassMock(1, "table");
workspaceMock.AddDataset(result);
return(result);
}
private static IObject CreateRow([NotNull] ObjectClassMock mockObjectClass,
int oid,
int urlFieldIndex,
string url)
{
IObject result = mockObjectClass.CreateObject(oid);
result.Value[urlFieldIndex] = (object) url ?? DBNull.Value;
return result;
}
private static IObject CreateRow([NotNull] ObjectClassMock mockObjectClass,
int oid,
int textFieldIndex,
string textFieldValue)
{
IObject result = mockObjectClass.CreateObject(oid);
result.Value[textFieldIndex] = (object)textFieldValue ?? DBNull.Value;
return(result);
}
private static ObjectClassMock CreateObjectClass([NotNull] string textFieldName,
out int textFieldIndex)
{
var result = new ObjectClassMock(1, "testtable");
result.AddField(FieldUtils.CreateTextField(textFieldName, 500));
textFieldIndex = result.FindField(textFieldName);
Assert.GreaterOrEqual(textFieldIndex, 0);
return(result);
}
public void CanOverrideCaseSensitivityWithoutPerformanceImpact()
{
const string textFieldName = "TEXTFIELD";
const string value = "aaa";
const int count = 50000;
int textFieldIndex;
ObjectClassMock objectClass = CreateObjectClass(textFieldName, out textFieldIndex);
// expect upper case for oids <= 2
string mustBeUpper = string.Format("{0} = '{1}'", textFieldName, value.ToUpper());
string mustBeEqualIgnoreCase = string.Format("{0} = '{1}'##IGNORECASE",
textFieldName, value.ToLower());
IObject row = CreateRow(objectClass, 1, textFieldIndex, value.ToUpper());
double referencePerformance = GetReferencePerformance(textFieldName, value, row,
count);
var constraintNodes = new List <ConstraintNode>
{
new ConstraintNode(mustBeUpper),
new ConstraintNode(mustBeEqualIgnoreCase)
};
var caseSensitiveTest = new QaConstraint(objectClass, constraintNodes);
caseSensitiveTest.SetSqlCaseSensitivity(0, true);
var caseSensitiveRunner = new QaTestRunner(caseSensitiveTest);
Stopwatch stopWatch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
Assert.AreEqual(0, caseSensitiveRunner.Execute(row));
}
stopWatch.Stop();
double milliSecondsPerRow = stopWatch.ElapsedMilliseconds / (double)count;
Console.WriteLine(@"{0:N0} ms ({1:N3} ms per row)",
stopWatch.ElapsedMilliseconds, milliSecondsPerRow);
Console.WriteLine(@"Reference (no overrides): {0:N3} ms per row",
referencePerformance);
Assert.Less(milliSecondsPerRow, referencePerformance * 1.5);
// allow for some variation
}
public void CanHandleHttpAndSimpleFieldExpression()
{
const string urlFieldName = "URL";
const string urlRoot = "http://localhost:8080/";
const string urlInfixExisting = "test/";
const string urlInfixNotExisting = "doesnotexist/";
const string existingPrefix = urlRoot + urlInfixExisting;
var objectClass = new ObjectClassMock(1, "testtable");
objectClass.AddField(FieldUtils.CreateTextField(urlFieldName, 500));
int urlFieldIndex = objectClass.FindField(urlFieldName);
Assert.IsTrue(urlFieldIndex >= 0);
// ok as long as prefix matches:
const string urlExistingPage = urlRoot + urlInfixExisting + "pagexy.html";
// not ok since prefix does not match:
const string urlNonExistingPage =
urlRoot + urlInfixNotExisting + "doesnotexist.html";
IObject rowWithExistingUrl = CreateRow(objectClass, 1, urlFieldIndex,
urlExistingPage);
IObject rowWithNonExistingUrl = CreateRow(objectClass, 2, urlFieldIndex,
urlNonExistingPage);
IObject rowWithNullUrl = CreateRow(objectClass, 2, urlFieldIndex, null);
// the expression contains no blanks - this checks for correct tokenization
string urlExpression = $"TRIM({urlFieldName})";
var errorCount = 0;
using (var webServer = new WebServer(SendHeadResponse, existingPrefix))
{
webServer.Run();
var test = new QaValidUrls(objectClass, urlExpression);
var runner = new QaTestRunner(test);
errorCount += runner.Execute(rowWithExistingUrl);
errorCount += runner.Execute(rowWithNonExistingUrl);
errorCount += runner.Execute(rowWithNullUrl);
}
Assert.AreEqual(1, errorCount);
}
public void CanCheckFtpServer()
{
// Explanation how to set up a ftp server with IIS comes here.
const string urlFieldName = "URL";
var objectClass = new ObjectClassMock(1, "testtable");
objectClass.AddField(FieldUtils.CreateTextField(urlFieldName, 500));
int urlFieldIndex = objectClass.FindField(urlFieldName);
Assert.IsTrue(urlFieldIndex >= 0);
const string url = "ftp://thisisnotimplementedyet.ch/test/";
IObject ftpUrl = CreateRow(objectClass, 1, urlFieldIndex, url);
var errorCount = 0;
var test = new QaValidUrls(objectClass, urlFieldName);
var runner = new QaTestRunner(test);
errorCount += runner.Execute(ftpUrl);
Assert.AreEqual(1, errorCount);
}
public void CanCheckFileSystem()
{
const string urlFieldName = "URL";
const string nameNonExistingFile = "doesnotexist.txt";
const string nameExistingFile = "_testfile.txt";
// C:\Users\<USER>\AppData\Local\Temp\
string pathNonExistingFile = Path.Combine(Path.GetTempPath(), nameNonExistingFile);
string pathExistingFile = Path.Combine(Path.GetTempPath(), nameExistingFile);
string uncPathExistingFile =
Path.Combine(
string.Format(@"\\{0}\C$\Users\{1}\AppData\Local\Temp",
Environment.MachineName, Environment.UserName),
nameExistingFile);
string uncPathExistingDirectory =
string.Format(@"\\{0}\C$\Users", Environment.MachineName);
string filePathExistingFile = string.Format("file:///{0}",
Path.Combine(Path.GetTempPath(),
nameExistingFile));
CreateTextFile(pathExistingFile);
try
{
var objectClass = new ObjectClassMock(1, "testtable");
objectClass.AddField(FieldUtils.CreateTextField(urlFieldName, 500));
int urlFieldIndex = objectClass.FindField(urlFieldName);
Assert.IsTrue(urlFieldIndex >= 0);
IObject rowNonExistingFile = CreateRow(objectClass, 1, urlFieldIndex,
pathNonExistingFile);
IObject rowExistingFile = CreateRow(objectClass, 2, urlFieldIndex,
pathExistingFile);
IObject rowExistingFileUncPath = CreateRow(objectClass, 3, urlFieldIndex,
uncPathExistingFile);
IObject rowExistingFilePath = CreateRow(objectClass, 4, urlFieldIndex,
filePathExistingFile);
IObject rowExistingDirectoryPath = CreateRow(objectClass, 5, urlFieldIndex,
uncPathExistingDirectory);
var errorCount = 0;
var test = new QaValidUrls(objectClass, urlFieldName);
var runner = new QaTestRunner(test);
errorCount += runner.Execute(rowNonExistingFile);
errorCount += runner.Execute(rowExistingFile);
errorCount += runner.Execute(rowExistingFileUncPath);
errorCount += runner.Execute(rowExistingFilePath);
errorCount += runner.Execute(rowExistingDirectoryPath);
// NOTE: 3 errors when offline (unc path to C$ on local machine cannot be resolved)
Assert.AreEqual(1, errorCount);
Assert.AreEqual(0, _webRequestCounts); // no http requests expected
}
finally
{
File.Delete(pathExistingFile);
}
}
public void CanOverrideCaseSensitivityForComplexCondition()
{
const string textFieldName = "TextField";
const string value = "aaa";
int textFieldIndex;
ObjectClassMock objectClass = CreateObjectClass(textFieldName, out textFieldIndex);
string ignoreCaseOverride = string.Format("{0} = '{1}'##IGNORECASE", textFieldName,
value.ToUpper());
string caseSensitiveOverride = string.Format("{0} = '{1}'##CASESENSITIVE",
textFieldName, value.ToLower());
// expect upper case for oids <= 2
string mustBeUpper = string.Format("{0} = '{1}'", textFieldName, value.ToUpper());
var selection1 = new ConstraintNode("OBJECTID <= 2");
selection1.Nodes.Add(new ConstraintNode(mustBeUpper));
selection1.Nodes.Add(new ConstraintNode(ignoreCaseOverride));
IObject row1 = CreateRow(objectClass, 1, textFieldIndex, value.ToUpper());
IObject row2 = CreateRow(objectClass, 2, textFieldIndex, value.ToLower());
// incorrect case
// expect lower case for oids > 2
string mustBeLower = string.Format("{0} = '{1}'", textFieldName, value.ToLower());
var selection2 = new ConstraintNode("OBJECTID > 2");
selection2.Nodes.Add(new ConstraintNode(mustBeLower));
selection2.Nodes.Add(new ConstraintNode(ignoreCaseOverride));
IObject row3 = CreateRow(objectClass, 3, textFieldIndex, value.ToLower());
IObject row4 = CreateRow(objectClass, 4, textFieldIndex, value.ToUpper());
// incorrect case
IObject row5 = CreateRow(objectClass, 5, textFieldIndex, value.ToUpper());
// incorrect case
var constraintNodes = new List <ConstraintNode> {
selection1, selection2
};
var caseSensitiveTest = new QaConstraint(objectClass, constraintNodes);
caseSensitiveTest.SetSqlCaseSensitivity(0, true);
var caseSensitiveRunner = new QaTestRunner(caseSensitiveTest);
Assert.AreEqual(0, caseSensitiveRunner.Execute(row1));
Assert.AreEqual(1, caseSensitiveRunner.Execute(row2));
Assert.AreEqual(
"testtable,2: OID = 2: Invalid value combination: OBJECTID = 2; TEXTFIELD = 'aaa' [Constraints.ConstraintNotFulfilled]",
caseSensitiveRunner.Errors[0].ToString());
caseSensitiveRunner.ClearErrors();
Assert.AreEqual(0, caseSensitiveRunner.Execute(row3));
Assert.AreEqual(1, caseSensitiveRunner.Execute(row4));
Assert.AreEqual(
"testtable,4: OID = 4: Invalid value combination: OBJECTID = 4; TEXTFIELD = 'AAA' [Constraints.ConstraintNotFulfilled]",
caseSensitiveRunner.Errors[0].ToString());
caseSensitiveRunner.ClearErrors();
Assert.AreEqual(1, caseSensitiveRunner.Execute(row5));
Assert.AreEqual(
"testtable,5: OID = 5: Invalid value combination: OBJECTID = 5; TEXTFIELD = 'AAA' [Constraints.ConstraintNotFulfilled]",
caseSensitiveRunner.Errors[0].ToString());
caseSensitiveRunner.ClearErrors();
var caseInsensitiveTest = new QaConstraint(objectClass, constraintNodes);
selection2.Nodes.Add(new ConstraintNode(caseSensitiveOverride));
var caseInsensitiveRunner = new QaTestRunner(caseInsensitiveTest);
Assert.AreEqual(0, caseInsensitiveRunner.Execute(row1));
Assert.AreEqual(0, caseInsensitiveRunner.Execute(row2));
Assert.AreEqual(0, caseInsensitiveRunner.Execute(row3));
Assert.AreEqual(1, caseInsensitiveRunner.Execute(row4));
Assert.AreEqual(
"testtable,4: OID = 4: Invalid value combination: OBJECTID = 4; TEXTFIELD = 'AAA' [Constraints.ConstraintNotFulfilled]",
caseInsensitiveRunner.Errors[0].ToString());
caseInsensitiveRunner.ClearErrors();
Assert.AreEqual(1, caseInsensitiveRunner.Execute(row5));
Assert.AreEqual(
"testtable,5: OID = 5: Invalid value combination: OBJECTID = 5; TEXTFIELD = 'AAA' [Constraints.ConstraintNotFulfilled]",
caseInsensitiveRunner.Errors[0].ToString());
caseInsensitiveRunner.ClearErrors();
}