public override void Execute(ExecutionContext context)
{
context.AssertRepositoryStarted();
var path = Path;
if (!string.IsNullOrEmpty(path))
{
path = path.Trim();
}
Logger.LogMessage((Recursive ? "Recursive integrity check. Scope: " : "Integrity check on: ") + (path ?? "/Root"));
var diff = IntegrityChecker.Check(path, Recursive);
Logger.LogMessage("Integrity check finished. Count of differences: " + diff.Count());
var outputLimit = OutputLimit == 0 ? int.MaxValue : OutputLimit;
var lines = 0;
foreach (var d in diff)
{
Logger.LogMessage(" " + d);
if (++lines >= outputLimit)
{
Logger.LogMessage("...truncated...");
break;
}
}
}
public static void FinishAllTests()
{
var diff = IntegrityChecker.Check();
Trace.WriteLine("&> Index integrity check after all tests. Count of differences: " + diff.Count());
foreach (var d in diff)
{
Trace.WriteLine("&> " + d);
}
Repository.Shutdown();
}
public void __Indexing_IndexIntegrityCheck()
{
var content = Content.CreateNew("Folder", TestRoot, "1");
var folder = (Folder)content.ContentHandler;
folder.InheritableVersioningMode = InheritableVersioningType.MajorOnly;
content.Save();
content = Content.CreateNew("Car", TestRoot, "Car_Indexing_IntegrityCheck_1");
content.Save();
var nodeId_1 = content.Id;
var versionId_1 = content.ContentHandler.VersionId;
content = Content.CreateNew("Car", TestRoot, "Car_Indexing_IntegrityCheck_2");
content.Save();
var nodeId_2 = content.Id;
var versionId_2 = content.ContentHandler.VersionId;
content = Content.CreateNew("Car", folder, "Car_Indexing_IntegrityCheck_3");
content.Save();
var nodeId_3 = content.Id;
var versionId_3 = content.ContentHandler.VersionId;
content = Content.CreateNew("Car", folder, "Car_Indexing_IntegrityCheck_4");
content.Save();
var gc = (GenericContent)content.ContentHandler;
var nodeId_4 = content.Id;
var versionId_4 = content.ContentHandler.VersionId;
var path_4 = gc.Path;
gc.Index++;
gc.Save();
var versionId_5 = content.ContentHandler.VersionId;
gc.Index++;
gc.Save();
var versionId_6 = content.ContentHandler.VersionId;
var diff0 = IntegrityChecker.Check();
if (diff0.Count() > 0)
{
Assert.Inconclusive("Cannot use this test if the initial state is inconsistent.");
}
AddFakeDocument(nodeId_1);
DeleteDocument(versionId_2);
Exec(String.Format("UPDATE Nodes SET [Index] = [Index] WHERE NodeId = {0}", nodeId_3));
Exec(String.Format("UPDATE Versions SET [Status] = [Status] WHERE VersionId = {0}", versionId_4));
//---- Total
var diff1 = IntegrityChecker.Check().ToArray();
Assert.IsTrue(diff1.Length == 4, String.Format("Count is {0}, expected: 4", diff1.Length));
Assert.IsTrue(diff1[0].Kind == IndexDifferenceKind.NotInIndex, String.Format("diff1[0].Kind is {0}, expected: NotInIndex", diff1[0].Kind));
Assert.IsTrue(diff1[0].VersionId == versionId_2, String.Format("diff1[0].Kind is {0}, expected: {1}", diff1[0].VersionId, versionId_2));
Assert.IsTrue(diff1[1].Kind == IndexDifferenceKind.DifferentNodeTimestamp, String.Format("diff1[1].Kind is {0}, expected: NotInIndex", diff1[1].Kind));
Assert.IsTrue(diff1[1].VersionId == versionId_3, String.Format("diff1[1].VersionId is {0}, expected: {1}", diff1[1].VersionId, versionId_3));
Assert.IsTrue(diff1[1].DbNodeTimestamp != diff1[1].IxNodeTimestamp, "diff1[1].DbNodeTimestamp == diff1[1].IxNodeTimestamp, expected: different.");
Assert.IsTrue(diff1[1].DbVersionTimestamp == diff1[1].IxVersionTimestamp, "diff1[1].DbVersionTimestamp != diff1[1].IxVersionTimestamp, expected: equal.");
Assert.IsTrue(diff1[2].Kind == IndexDifferenceKind.DifferentVersionTimestamp, String.Format("diff1[2].Kind is {0}, expected: NotInIndex", diff1[2].Kind));
Assert.IsTrue(diff1[2].VersionId == versionId_4, String.Format("diff1[2].VersionId is {0}, expected: {1}", diff1[2].VersionId, versionId_4));
Assert.IsTrue(diff1[2].DbNodeTimestamp != diff1[2].IxNodeTimestamp, "diff1[2].DbNodeTimestamp == diff1[2].IxNodeTimestamp, expected: different."); // older version !
Assert.IsTrue(diff1[2].DbVersionTimestamp != diff1[2].IxVersionTimestamp, "diff1[2].DbVersionTimestamp == diff1[2].IxVersionTimestamp, expected: different.");
Assert.IsTrue(diff1[3].Kind == IndexDifferenceKind.NotInDatabase, String.Format("diff1[3].Kind is {0}, expected: NotInDatabase", diff1[3].Kind));
Assert.IsTrue(diff1[3].VersionId == 99999, String.Format("diff1[3].VersionId is {0}, expected: 99999", diff1[3].VersionId));
Assert.IsTrue(diff1[3].NodeId == 99999, String.Format("diff1[3].NodeId is {0}, expected: 99999", diff1[3].NodeId));
Assert.IsTrue(diff1[3].Path == "/root/fakedocument", String.Format("diff1[3].Path is {0}, expected: /root/fakedocument", diff1[3].Path));
//---- Subtree
var diff2 = IntegrityChecker.Check(folder.Path, true).ToArray();
Assert.IsTrue(diff2[0].Kind == IndexDifferenceKind.DifferentNodeTimestamp, String.Format("diff3[0].Kind is {0}, expected: NotInIndex", diff2[0].Kind));
Assert.IsTrue(diff2[0].VersionId == versionId_3, String.Format("diff3[0].VersionId is {0}, expected: {1}", diff2[0].VersionId, versionId_3));
Assert.IsTrue(diff2[0].DbNodeTimestamp != diff2[0].IxNodeTimestamp, "diff3[0].DbNodeTimestamp == diff3[0].IxNodeTimestamp, expected: different.");
Assert.IsTrue(diff2[0].DbVersionTimestamp == diff2[0].IxVersionTimestamp, "diff3[0].DbVersionTimestamp != diff3[0].IxVersionTimestamp, expected: equal.");
Assert.IsTrue(diff2[1].Kind == IndexDifferenceKind.DifferentVersionTimestamp, String.Format("diff3[1].Kind is {0}, expected: NotInIndex", diff2[1].Kind));
Assert.IsTrue(diff2[1].VersionId == versionId_4, String.Format("diff3[1].VersionId is {0}, expected: {1}", diff2[1].VersionId, versionId_4));
Assert.IsTrue(diff2[1].DbNodeTimestamp != diff2[1].IxNodeTimestamp, "diff3[1].DbNodeTimestamp == diff3[1].IxNodeTimestamp, expected: different."); // older version
Assert.IsTrue(diff2[1].DbVersionTimestamp != diff2[1].IxVersionTimestamp, "diff3[1].DbVersionTimestamp == diff3[1].IxVersionTimestamp, expected: different.");
//---- Node not recursive not changed
var diff3 = IntegrityChecker.Check(folder.Path, false).ToArray();
Assert.IsTrue(diff3.Length == 0, String.Format("diff3.Length is {0}, expected: 0.", diff3.Length));
//---- Node not recursive an old version changed
var diff4 = IntegrityChecker.Check(path_4, false).ToArray();
Assert.IsTrue(diff4.Length == 1, String.Format("diff4.Length is {0}, expected: 1.", diff3.Length));
Assert.IsTrue(diff4[0].Kind == IndexDifferenceKind.DifferentVersionTimestamp, String.Format("diff4[0].Kind is {0}, expected: NotInIndex", diff4[0].Kind));
Assert.IsTrue(diff4[0].VersionId == versionId_4, String.Format("diff4[0].VersionId is {0}, expected: {1}", diff4[0].VersionId, versionId_4));
Assert.IsTrue(diff4[0].DbNodeTimestamp != diff4[0].IxNodeTimestamp, "diff4[0].DbNodeTimestamp == diff4[0].IxNodeTimestamp, expected: different."); // older version
Assert.IsTrue(diff4[0].DbVersionTimestamp != diff4[0].IxVersionTimestamp, "diff4[0].DbVersionTimestamp == diff4[0].IxVersionTimestamp, expected: different.");
}