public void TestUpdateIndex()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
var fileName = Path.Combine(MonitorFolder, "A.txt");
File.AppendAllText(fileName, "ABCD Eeee EEEE");
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(fileName)));
Assert.AreEqual("ABCD Eeee EEEE", indexBuilder.CodeIndexPool.SearchCode(new MatchAllDocsQuery()).First().Content);
CollectionAssert.AreEquivalent(new[] { "ABCD", "Eeee", "EEEE" }, indexBuilder.HintIndexPool.SearchWord(new MatchAllDocsQuery()).Select(u => u.Word));
File.Delete(fileName);
File.AppendAllText(fileName, "WOWO IT IS NEW CONTENT APPLY ABCD EEEE");
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.UpdateIndex(new FileInfo(fileName), CancellationToken.None));
Assert.AreEqual("WOWO IT IS NEW CONTENT APPLY ABCD EEEE", indexBuilder.CodeIndexPool.SearchCode(new MatchAllDocsQuery()).First().Content);
CollectionAssert.AreEquivalent(new[] { "WOWO", "ABCD", "CONTENT", "APPLY", "EEEE" }, indexBuilder.HintIndexPool.SearchWord(new MatchAllDocsQuery()).Select(u => u.Word), "Words Been Added And Removed If Needed");
var fileName2 = Path.Combine(MonitorFolder, "B.txt");
File.AppendAllText(fileName2, "ABCD Eeee");
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(fileName2)));
CollectionAssert.AreEquivalent(new[] { "WOWO", "ABCD", "CONTENT", "APPLY", "Eeee", "EEEE" }, indexBuilder.HintIndexPool.SearchWord(new MatchAllDocsQuery()).Select(u => u.Word), "Words Been Added And Removed If Needed");
File.Delete(fileName2);
File.AppendAllText(fileName2, "Eeee");
CollectionAssert.AreEquivalent(new[] { "WOWO", "ABCD", "CONTENT", "APPLY", "Eeee", "EEEE" }, indexBuilder.HintIndexPool.SearchWord(new MatchAllDocsQuery()).Select(u => u.Word), "Words Been Added And Removed If Needed");
}
public void TestUpdateIndex()
{
BuildIndex();
LucenePool.SaveResultsAndClearLucenePool(Config.LuceneIndexForCode);
var result = CodeIndexSearcher.Search(Config.LuceneIndexForCode, new TermQuery(new Term(nameof(CodeSource.FilePath) + Constants.NoneTokenizeFieldSuffix, @"D:\DDDD\A new Name.cs")), 10);
Assert.That(result.Length, Is.EqualTo(1));
CodeIndexBuilder.UpdateIndex(Config.LuceneIndexForCode, new Term(nameof(CodeSource.FilePath) + Constants.NoneTokenizeFieldSuffix, @"d:\dddd\a new name.cs"), CodeIndexBuilder.GetDocumentFromSource(new CodeSource()
{
Content = "AAA",
FileExtension = "CCC",
FilePath = "BBB",
FileName = "DDD",
IndexDate = new DateTime(1999, 12, 31),
LastWriteTimeUtc = new DateTime(2000, 1, 1)
}));
LucenePool.SaveResultsAndClearLucenePool(Config.LuceneIndexForCode);
result = CodeIndexSearcher.Search(Config.LuceneIndexForCode, new TermQuery(new Term(nameof(CodeSource.FilePath) + Constants.NoneTokenizeFieldSuffix, @"d:\dddd\a new name.cs")), 10);
Assert.That(result.Length, Is.EqualTo(0));
result = CodeIndexSearcher.Search(Config.LuceneIndexForCode, new TermQuery(new Term(nameof(CodeSource.FilePath) + Constants.NoneTokenizeFieldSuffix, "BBB")), 10);
Assert.That(result.Length, Is.EqualTo(1));
Assert.AreEqual(@"DDD", result[0].Get(nameof(CodeSource.FileName)));
Assert.AreEqual(@"CCC", result[0].Get(nameof(CodeSource.FileExtension)));
Assert.AreEqual(@"BBB", result[0].Get(nameof(CodeSource.FilePath)));
Assert.AreEqual("AAA", result[0].Get(nameof(CodeSource.Content)));
Assert.AreEqual(new DateTime(1999, 12, 31).Ticks, result[0].GetField(nameof(CodeSource.IndexDate)).GetInt64Value());
Assert.AreEqual(new DateTime(2000, 1, 1).Ticks, result[0].GetField(nameof(CodeSource.LastWriteTimeUtc)).GetInt64Value());
}
public void TestSearch_ReaderFromWriter()
{
CodeIndexBuilder.BuildIndex(Config, true, true, true, new[] { new CodeSource
{
FileName = "Dummy File 1",
FileExtension = "cs",
FilePath = @"C:\Dummy File 1.cs",
Content = "Test Content" + Environment.NewLine + "A New Line For Test"
},
new CodeSource
{
FileName = "Dummy File 2",
FileExtension = "cs",
FilePath = @"C:\Dummy File 2.cs",
Content = "Test Content" + Environment.NewLine + "A New Line For Test"
},
new CodeSource
{
FileName = "Dummy File 2",
FileExtension = "xml",
FilePath = @"C:\Dummy File.xml",
Content = "Test Content" + Environment.NewLine + "A New Line For Test"
} });
var results = CodeIndexSearcher.Search(Config.LuceneIndexForCode, new TermQuery(new Term(nameof(CodeSource.FileExtension), "xml")), 10);
Assert.That(results.Length, Is.EqualTo(1));
}
public void TestInitializeIndex()
{
Directory.CreateDirectory(MonitorFolder);
File.WriteAllText(Path.Combine(MonitorFolder, "A.txt"), "I have an apple");
Directory.CreateDirectory(Path.Combine(MonitorFolder, "Sub"));
File.WriteAllText(Path.Combine(MonitorFolder, "Sub", "B.txt"), "I have a peach");
var log = new DummyLog();
var initializer = new IndexInitializer(log);
initializer.InitializeIndex(Config, out _);
StringAssert.Contains($"Create index folder {Config.LuceneIndexForCode}", log.LogsContent);
StringAssert.Contains($"Create index folder {Config.LuceneIndexForHint}", log.LogsContent);
var codeSources = CodeIndexBuilder.GetAllIndexedCodeSource(Config.LuceneIndexForCode);
Assert.AreEqual(2, codeSources.Count);
CollectionAssert.AreEquivalent(new[] { Path.Combine(MonitorFolder, "A.txt"), Path.Combine(MonitorFolder, "Sub", "B.txt") }, codeSources.Select(u => u.FilePath));
File.WriteAllText(Path.Combine(MonitorFolder, "C.txt"), "I have a pear");
File.AppendAllText(Path.Combine(MonitorFolder, "A.txt"), "Now I have two apples");
File.Delete(Path.Combine(MonitorFolder, "Sub", "B.txt"));
initializer.InitializeIndex(Config, out _);
StringAssert.Contains("Compare index difference", log.LogsContent);
StringAssert.Contains($"File {Path.Combine(MonitorFolder, "A.txt")} modified", log.LogsContent);
StringAssert.Contains($"File {Path.Combine(MonitorFolder, "Sub", "B.txt")} deleted", log.LogsContent);
StringAssert.Contains($"Found new file {Path.Combine(MonitorFolder, "C.txt")}", log.LogsContent);
codeSources = CodeIndexBuilder.GetAllIndexedCodeSource(Config.LuceneIndexForCode);
Assert.AreEqual(2, codeSources.Count);
CollectionAssert.AreEquivalent(new[] { Path.Combine(MonitorFolder, "A.txt"), Path.Combine(MonitorFolder, "C.txt") }, codeSources.Select(u => u.FilePath));
}
void UpdateIndex(string fullPath, PendingRetrySource pendingRetrySource = null)
{
if (IsFile(fullPath))
{
var fileInfo = new FileInfo(fullPath);
try
{
Thread.Sleep(WaitMilliseconds); // Wait to let file finished write to disk
if (fileInfo.Exists)
{
var content = FilesContentHelper.ReadAllText(fullPath);
var document = CodeIndexBuilder.GetDocumentFromSource(CodeSource.GetCodeSource(fileInfo, content));
CodeIndexBuilder.UpdateIndex(config.LuceneIndexForCode, GetNoneTokenizeFieldTerm(nameof(CodeSource.FilePath), fullPath), document);
WordsHintBuilder.UpdateWordsHint(config, WordSegmenter.GetWords(content), log);
pendingChanges++;
}
}
catch (IOException)
{
AddFileChangesToRetrySouce(fullPath, WatcherChangeTypes.Changed, pendingRetrySource);
}
catch (Exception ex)
{
log?.Error(ex.ToString());
}
}
}
public void TestRenameFolderIndexes()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
var oldPath = Path.Combine(MonitorFolder, "ABC");
Directory.CreateDirectory(oldPath);
var newPath = Path.Combine(MonitorFolder, "EFG");
var oldFileName = Path.Combine(oldPath, "A.txt");
var newFileName = Path.Combine(newPath, "A.txt");
File.AppendAllText(oldFileName, "ABCD EEEE");
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(oldFileName)));
Assert.AreEqual(oldFileName, indexBuilder.CodeIndexPool.SearchCode(new MatchAllDocsQuery()).First().FilePath);
Directory.Move(oldPath, newPath);
Assert.IsTrue(indexBuilder.RenameFolderIndexes(oldPath, newPath, CancellationToken.None));
Assert.AreEqual(newFileName, indexBuilder.CodeIndexPool.SearchCode(new MatchAllDocsQuery()).First().FilePath);
var results = indexBuilder.CodeIndexPool.SearchCode(new PrefixQuery(indexBuilder.GetNoneTokenizeFieldTerm(nameof(CodeSource.FilePath), newPath)));
Assert.AreEqual(1, results.Length);
Assert.AreEqual(newFileName, results[0].FilePath);
Assert.AreEqual("ABCD EEEE", results[0].Content);
}
public void TestBuildIndexByBatch()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
var fileName1 = Path.Combine(MonitorFolder, "A.txt");
var fileName2 = Path.Combine(MonitorFolder, "B.txt");
File.AppendAllText(fileName1, "ABCD ABCD" + Environment.NewLine + "ABCD");
File.AppendAllText(fileName2, "ABCD EFGH");
var failedFiles = indexBuilder.BuildIndexByBatch(new[] { new FileInfo(fileName1), new FileInfo(fileName2) }, true, true, true, CancellationToken.None, true);
CollectionAssert.IsEmpty(failedFiles);
var results = indexBuilder.CodeIndexPool.SearchCode(Generator.GetQueryFromStr("ABCD", false));
Assert.AreEqual(2, results.Length);
Assert.AreEqual("A.txt", results[0].FileName);
Assert.AreEqual("txt", results[0].FileExtension);
Assert.AreEqual(fileName1, results[0].FilePath);
Assert.AreEqual("ABCD ABCD" + Environment.NewLine + "ABCD", results[0].Content);
Assert.GreaterOrEqual(DateTime.UtcNow, results[0].IndexDate);
Assert.AreEqual("B.txt", results[1].FileName);
Assert.AreEqual("txt", results[1].FileExtension);
Assert.AreEqual(fileName2, results[1].FilePath);
Assert.AreEqual("ABCD EFGH", results[1].Content);
Assert.GreaterOrEqual(DateTime.UtcNow, results[1].IndexDate);
Assert.AreEqual(1, indexBuilder.CodeIndexPool.SearchCode(Generator.GetQueryFromStr("EFGH", false)).Length);
Assert.AreEqual(1, indexBuilder.HintIndexPool.SearchWord(new TermQuery(new Term(nameof(CodeWord.Word), "ABCD"))).Length);
Assert.AreEqual(1, indexBuilder.HintIndexPool.SearchWord(new TermQuery(new Term(nameof(CodeWord.Word), "EFGH"))).Length);
}
void CreateNewIndex(string fullPath, PendingRetrySource pendingRetrySource = null)
{
if (IsFile(fullPath))
{
var fileInfo = new FileInfo(fullPath);
try
{
Thread.Sleep(WaitMilliseconds); // Wait to let file finished write to disk
if (fileInfo.Exists)
{
var content = FilesContentHelper.ReadAllText(fullPath);
CodeIndexBuilder.BuildIndex(config, false, false, false, new[] { CodeSource.GetCodeSource(fileInfo, content) });
WordsHintBuilder.UpdateWordsHint(config, WordSegmenter.GetWords(content), log);
pendingChanges++;
}
}
catch (IOException)
{
AddFileChangesToRetrySouce(fullPath, WatcherChangeTypes.Created, pendingRetrySource);
}
catch (Exception ex)
{
log?.Error(ex.ToString());
}
}
}
public void TestCreateIndex()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
var fileName = Path.Combine(MonitorFolder, "A.txt");
File.AppendAllText(fileName, "ABCD EEEE");
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(fileName)));
var results = indexBuilder.CodeIndexPool.SearchCode(new MatchAllDocsQuery());
var words = indexBuilder.HintIndexPool.SearchWord(new MatchAllDocsQuery());
Assert.AreEqual(1, results.Length);
Assert.AreEqual(2, words.Length);
Assert.AreEqual("A.txt", results[0].FileName);
Assert.AreEqual("txt", results[0].FileExtension);
Assert.AreEqual(fileName, results[0].FilePath);
Assert.AreEqual("ABCD EEEE", results[0].Content);
Assert.GreaterOrEqual(DateTime.UtcNow, results[0].IndexDate);
CollectionAssert.AreEquivalent(new[] { "ABCD", "EEEE" }, words.Select(u => u.Word));
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(fileName)));
results = indexBuilder.CodeIndexPool.SearchCode(new MatchAllDocsQuery());
words = indexBuilder.HintIndexPool.SearchWord(new MatchAllDocsQuery());
Assert.AreEqual(1, results.Length, "No Duplicate Index Created");
Assert.AreEqual(2, words.Length, "No Duplicate Index Created");
}
public void TestThreadSafeForIndexReader()
{
CodeIndexBuilder.BuildIndex(Config, true, true, true, new[] {
new CodeSource
{
FileName = "Dummy File 1",
FileExtension = "cs",
FilePath = @"C:\Dummy File 1.cs",
Content = "Test Content" + Environment.NewLine + "A New Line For Test"
},
new CodeSource
{
FileName = "Dummy File 2",
FileExtension = "cs",
FilePath = @"C:\Dummy File 2.cs",
Content = "Test Content" + Environment.NewLine + "A New Line For Test"
},
new CodeSource
{
FileName = "Dummy File 2",
FileExtension = "xml",
FilePath = @"C:\Dummy File.xml",
Content = "Test Content" + Environment.NewLine + "A New Line For Test"
}
});
LucenePool.SaveResultsAndClearLucenePool(Config);
var taskList = new List <Task>();
for (int i = 0; i < 20; i++)
{
taskList.Add(Task.Run(() =>
{
for (int j = 0; j < 50; j++)
{
if (j % 4 == 0)
{
CodeIndexBuilder.BuildIndex(Config, true, true, true, new[] {
new CodeSource
{
FileName = $"Dummy File 1 {i} {j}",
FileExtension = "cs",
FilePath = $@"C:\Dummy File 1 {i} {j}.cs",
Content = "Test Content" + Environment.NewLine + "A New Line For Test"
}
});
}
LucenePool.Search(Config.LuceneIndexForCode, new MatchAllDocsQuery(), int.MaxValue);
LucenePool.Search(Config.LuceneIndexForCode, new MatchAllDocsQuery(), int.MaxValue);
}
}));
}
Assert.DoesNotThrowAsync(async() => await Task.WhenAll(taskList));
}
public void TestGetAllHintWords()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
File.AppendAllText(Path.Combine(MonitorFolder, "A.txt"), "ABCD EEEE WoWo Eeee Abcd");
File.AppendAllText(Path.Combine(MonitorFolder, "B.txt"), "Neww Content WoWo skrskrskr");
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(Path.Combine(MonitorFolder, "A.txt"))));
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(Path.Combine(MonitorFolder, "B.txt"))));
CollectionAssert.AreEquivalent(new[] { "ABCD", "EEEE", "WoWo", "Eeee", "Abcd", "Neww", "Content", "skrskrskr" }, indexBuilder.GetAllHintWords());
}
public void TestGetNoneTokenizeFieldTerm()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
var term = indexBuilder.GetNoneTokenizeFieldTerm("ABC", "Value");
Assert.AreEqual("ABC" + Constants.NoneTokenizeFieldSuffix, term.Field);
Assert.AreEqual("Value", term.Text());
}
public void TestInitIndexFolderIfNeeded()
{
Assert.IsFalse(Directory.Exists(Config.LuceneIndexForCode));
Assert.IsFalse(Directory.Exists(Config.LuceneIndexForHint));
CodeIndexBuilder.InitIndexFolderIfNeeded(Config, null);
Assert.IsTrue(Directory.Exists(Config.LuceneIndexForCode));
Assert.IsTrue(Directory.Exists(Config.LuceneIndexForHint));
}
public void TestGetContentSearchStr()
{
Assert.Multiple(() =>
{
Assert.IsEmpty(Generator.GetContentSearchStr(null, false));
Assert.IsEmpty(Generator.GetContentSearchStr(" ", true));
Assert.AreEqual($"{nameof(CodeSource.Content)}:A", Generator.GetContentSearchStr("A", false));
Assert.AreEqual($"{CodeIndexBuilder.GetCaseSensitiveField(nameof(CodeSource.Content))}:A", Generator.GetContentSearchStr("A", true));
});
}
public void TestInitIndexFolderIfNeeded()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
Assert.IsFalse(Directory.Exists(TempCodeIndexDir));
Assert.IsFalse(Directory.Exists(TempHintIndexDir));
indexBuilder.InitIndexFolderIfNeeded();
Assert.IsTrue(Directory.Exists(TempCodeIndexDir));
Assert.IsTrue(Directory.Exists(TempHintIndexDir));
}
public void TestDeleteAllIndex()
{
BuildIndex();
LucenePool.SaveResultsAndClearLucenePool(Config.LuceneIndexForCode);
Assert.AreEqual(1, CodeIndexSearcher.Search(Config.LuceneIndexForCode, Generator.GetQueryFromStr($"{nameof(CodeSource.FileName)}:\"Dummy File\""), 10).Length);
Assert.AreEqual(1, CodeIndexSearcher.Search(Config.LuceneIndexForCode, Generator.GetQueryFromStr($"{nameof(CodeSource.FileName)}:\"A new File\""), 10).Length);
CodeIndexBuilder.DeleteAllIndex(Config);
Assert.AreEqual(0, CodeIndexSearcher.Search(Config.LuceneIndexForCode, Generator.GetQueryFromStr($"{nameof(CodeSource.FileName)}:\"Dummy File\""), 10).Length);
Assert.AreEqual(0, CodeIndexSearcher.Search(Config.LuceneIndexForCode, Generator.GetQueryFromStr($"{nameof(CodeSource.FileName)}:\"A new File\""), 10).Length);
}
public void TestBuildIndexByBatch_ReturnFailedFiles()
{
File.WriteAllText(Path.Combine(TempDir, "A.txt"), "ABCD");
CodeIndexBuilder.BuildIndexByBatch(Config, true, true, true, new[] { new FileInfo(Path.Combine(TempDir, "A.txt")) }, false, new DummyLog {
ThrowExceptionWhenLogContains = "Add index For " + Path.Combine(TempDir, "A.txt")
}, out var failedIndexFiles);
Assert.AreEqual(1, failedIndexFiles.Count);
CodeIndexBuilder.BuildIndexByBatch(Config, true, true, true, new[] { new FileInfo(Path.Combine(TempDir, "A.txt")), new FileInfo("BlaBla\\a.txt") }, false, null, out failedIndexFiles);
Assert.AreEqual(0, failedIndexFiles.Count);
}
void DeleteIndex(string fullPath)
{
try
{
CodeIndexBuilder.DeleteIndex(config.LuceneIndexForCode, GetNoneTokenizeFieldTerm(nameof(CodeSource.FilePath), fullPath));
pendingChanges++;
}
catch (Exception ex)
{
log?.Error(ex.ToString());
}
}
public void TestIndexExists()
{
Assert.IsFalse(CodeIndexBuilder.IndexExists(Config.LuceneIndexForCode));
BuildIndex();
Assert.IsFalse(CodeIndexBuilder.IndexExists(Config.LuceneIndexForCode));
LucenePool.SaveResultsAndClearLucenePool(Config.LuceneIndexForCode);
Assert.IsTrue(CodeIndexBuilder.IndexExists(Config.LuceneIndexForCode));
}
void DeleteAllDocumentsIndexUnder(string forderOldFullPath)
{
try
{
var term = new PrefixQuery(GetNoneTokenizeFieldTerm(nameof(CodeSource.FilePath), forderOldFullPath));
CodeIndexBuilder.DeleteIndex(config.LuceneIndexForCode, term);
pendingChanges++;
}
catch (Exception ex)
{
log?.Error(ex.ToString());
}
}
public void TestGetContentSearchQuery_NormalQuery()
{
var query = Generator.GetContentSearchQuery(new SearchRequest
{
CaseSensitive = false,
Content = "ABC*",
});
Assert.NotNull(query);
Assert.AreEqual("Content:abc*", query.ToString());
query = Generator.GetContentSearchQuery(new SearchRequest
{
CaseSensitive = true,
Content = "ABC*",
});
Assert.AreEqual($"{CodeIndexBuilder.GetCaseSensitiveField(nameof(CodeSource.Content))}:ABC*", query.ToString());
query = Generator.GetContentSearchQuery(new SearchRequest
{
CaseSensitive = false,
Content = "Abc~2",
});
Assert.AreEqual($"Content:abc~2", query.ToString());
query = Generator.GetContentSearchQuery(new SearchRequest
{
CaseSensitive = true,
Content = "Abc~2",
});
Assert.AreEqual($"{CodeIndexBuilder.GetCaseSensitiveField(nameof(CodeSource.Content))}:Abc~2", query.ToString());
query = Generator.GetContentSearchQuery(new SearchRequest
{
CaseSensitive = true,
Content = " ",
});
Assert.IsNull(query);
query = Generator.GetContentSearchQuery(new SearchRequest
{
CaseSensitive = false,
Content = null,
});
Assert.IsNull(query);
}
protected string GetContentSearchStr(string content, bool caseSensitive)
{
if (!string.IsNullOrWhiteSpace(content))
{
if (caseSensitive)
{
return($"{CodeIndexBuilder.GetCaseSensitiveField(nameof(CodeSource.Content))}:{content}");
}
return($"{nameof(CodeSource.Content)}:{content}");
}
return(string.Empty);
}
public void TestDeleteIndex()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
File.AppendAllText(Path.Combine(MonitorFolder, "A.txt"), "ABCD EEEE dddd");
File.AppendAllText(Path.Combine(MonitorFolder, "B.txt"), "ABCD DDDD eeEE");
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(Path.Combine(MonitorFolder, "A.txt"))));
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(Path.Combine(MonitorFolder, "B.txt"))));
Assert.AreEqual(2, indexBuilder.CodeIndexPool.SearchCode(new MatchAllDocsQuery()).Length);
CollectionAssert.AreEquivalent(new[] { "ABCD", "EEEE", "DDDD", "dddd", "eeEE" }, indexBuilder.HintIndexPool.SearchWord(new MatchAllDocsQuery()).Select(u => u.Word));
Assert.IsTrue(indexBuilder.DeleteIndex(Path.Combine(MonitorFolder, "A.txt")));
Assert.AreEqual(1, indexBuilder.CodeIndexPool.SearchCode(new MatchAllDocsQuery()).Length);
CollectionAssert.AreEquivalent(new[] { "ABCD", "DDDD", "eeEE" }, indexBuilder.HintIndexPool.SearchWord(new MatchAllDocsQuery()).Select(u => u.Word), "Words Been Removed If Needed");
}
public void TestCommit()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
File.AppendAllText(Path.Combine(MonitorFolder, "A.txt"), "ABCD EEEE");
Assert.AreEqual(IndexBuildResults.Successful, indexBuilder.CreateIndex(new FileInfo(Path.Combine(MonitorFolder, "A.txt"))));
Assert.IsFalse(IndexBuilderHelper.IndexExists(TempCodeIndexDir));
indexBuilder.Commit();
Assert.IsTrue(IndexBuilderHelper.IndexExists(TempCodeIndexDir));
using var dir = Lucene.Net.Store.FSDirectory.Open(TempCodeIndexDir);
using var reader = DirectoryReader.Open(dir);
var searcher = new IndexSearcher(reader);
Assert.AreEqual(1, searcher.Search(new MatchAllDocsQuery(), 1).TotalHits);
}
public void TestUpdateCodeFilePath()
{
var document = CodeIndexBuilder.GetDocumentFromSource(new CodeSource
{
Content = "AAA",
FileExtension = "CCC",
FilePath = "BBB/DDD/1.txt",
FileName = "1.txt",
IndexDate = new DateTime(1999, 12, 31),
LastWriteTimeUtc = new DateTime(2000, 1, 1)
});
CodeIndexBuilder.UpdateCodeFilePath(document, "BBB/DDD/", "AAA/EEE/");
Assert.AreEqual(@"AAA/EEE/1.txt", document.Get(nameof(CodeSource.FilePath)));
Assert.AreEqual(@"AAA/EEE/1.txt", document.Get(nameof(CodeSource.FilePath) + Constants.NoneTokenizeFieldSuffix));
}
public void TestGetAllIndexedCodeSource()
{
Directory.CreateDirectory(MonitorFolder);
File.WriteAllText(Path.Combine(MonitorFolder, "A.txt"), "I have an apple");
File.WriteAllText(Path.Combine(MonitorFolder, "B.txt"), "I have two apples");
var initializer = new IndexInitializer(null);
initializer.InitializeIndex(Config, out _);
var codeSources = CodeIndexBuilder.GetAllIndexedCodeSource(Config.LuceneIndexForCode);
Assert.AreEqual(2, codeSources.Count);
CollectionAssert.AreEquivalent(new[] { Path.Combine(MonitorFolder, "A.txt"), Path.Combine(MonitorFolder, "B.txt") }, codeSources.Select(u => u.FilePath));
CollectionAssert.AreEquivalent(new[] { new FileInfo(Path.Combine(MonitorFolder, "A.txt")).LastWriteTimeUtc, new FileInfo(Path.Combine(MonitorFolder, "B.txt")).LastWriteTimeUtc }, codeSources.Select(u => u.LastWriteTimeUtc));
}
public void TestGetAllIndexedCodeSource()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
var fileName1 = Path.Combine(MonitorFolder, "A.txt");
var fileName2 = Path.Combine(MonitorFolder, "B.txt");
File.AppendAllText(fileName1, "ABCD ABCD");
File.AppendAllText(fileName2, "EFGH");
var file1Info = new FileInfo(fileName1);
var file2Info = new FileInfo(fileName2);
var failedFiles = indexBuilder.BuildIndexByBatch(new[] { new FileInfo(fileName1), new FileInfo(fileName2) }, true, true, true, CancellationToken.None, true);
CollectionAssert.IsEmpty(failedFiles);
CollectionAssert.AreEquivalent(new[] { (file1Info.FullName, file1Info.LastWriteTimeUtc), (file2Info.FullName, file2Info.LastWriteTimeUtc) }, indexBuilder.GetAllIndexedCodeSource());
void BuildIndex()
{
CodeIndexBuilder.BuildIndex(Config, true, true, true, new[] { new CodeSource
{
FileName = "Dummy File",
FileExtension = "cs",
FilePath = @"C:\Dummy File.cs",
Content = "Test Content" + Environment.NewLine + "A New Line For Test",
IndexDate = new DateTime(2020, 1, 1)
},
new CodeSource
{
FileName = "A new File",
FileExtension = "xml",
FilePath = @"D:\DDDD\A new Name.cs",
Content = "FFFF Content A new Line"
} });
}
public void TestBuildIndexByBatch_FailedFiles()
{
using var indexBuilder = new CodeIndexBuilder("ABC", new LucenePoolLight(TempCodeIndexDir), new LucenePoolLight(TempHintIndexDir), Log);
var fileName1 = Path.Combine(MonitorFolder, "A.txt");
var fileName2 = Path.Combine(MonitorFolder, "B.txt");
var file = File.Create(fileName1);
File.AppendAllText(fileName2, "ABCD ABCD");
try
{
var failedFiles = indexBuilder.BuildIndexByBatch(new[] { new FileInfo(fileName1), new FileInfo(fileName2) }, true, true, true, CancellationToken.None, true);
CollectionAssert.AreEquivalent(new[] { fileName1 }, failedFiles.Select(u => u.FullName));
}
finally
{
file.Dispose();
}
}
public void TestDeleteIndex()
{
BuildIndex();
LucenePool.SaveResultsAndClearLucenePool(Config.LuceneIndexForCode);
var generator = new QueryGenerator();
var result = CodeIndexSearcher.Search(Config.LuceneIndexForCode, generator.GetQueryFromStr("FFFF test"), 10);
Assert.That(result.Length, Is.EqualTo(2));
CodeIndexBuilder.DeleteIndex(Config.LuceneIndexForCode, new Term(nameof(CodeSource.FileExtension), "xml"));
LucenePool.SaveResultsAndClearLucenePool(Config.LuceneIndexForCode);
result = CodeIndexSearcher.Search(Config.LuceneIndexForCode, generator.GetQueryFromStr("FFFF test"), 10);
Assert.That(result.Length, Is.EqualTo(1));
CodeIndexBuilder.DeleteIndex(Config.LuceneIndexForCode, generator.GetQueryFromStr("Test"));
LucenePool.SaveResultsAndClearLucenePool(Config.LuceneIndexForCode);
result = CodeIndexSearcher.Search(Config.LuceneIndexForCode, generator.GetQueryFromStr("FFFF test"), 10);
Assert.That(result.Length, Is.EqualTo(0));
}
