mirror of
https://github.com/zadam/trilium.git
synced 2025-11-18 03:00:41 +01:00
868 lines
43 KiB
TypeScript
868 lines
43 KiB
TypeScript
/**
|
|
* Comprehensive Fuzzy Search Tests
|
|
*
|
|
* Tests all fuzzy search features documented in search.md:
|
|
* - Fuzzy exact match (~=) with edit distances
|
|
* - Fuzzy contains (~*) with spelling variations
|
|
* - Edit distance boundary testing
|
|
* - Minimum token length validation
|
|
* - Diacritic normalization
|
|
* - Fuzzy matching in different contexts (title, content, labels, relations)
|
|
* - Progressive search integration
|
|
* - Fuzzy score calculation and ranking
|
|
* - Edge cases
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach } from "vitest";
|
|
import searchService from "./services/search.js";
|
|
import BNote from "../../becca/entities/bnote.js";
|
|
import BBranch from "../../becca/entities/bbranch.js";
|
|
import SearchContext from "./search_context.js";
|
|
import becca from "../../becca/becca.js";
|
|
import { findNoteByTitle, note, NoteBuilder } from "../../test/becca_mocking.js";
|
|
|
|
/**
|
|
* NOTE: ALL TESTS IN THIS FILE ARE CURRENTLY SKIPPED
|
|
*
|
|
* Fuzzy search operators (~= and ~*) are not yet implemented in the search engine.
|
|
* These comprehensive tests are ready to validate fuzzy search functionality when the feature is added.
|
|
* See search.md lines 72-86 for the fuzzy search specification.
|
|
*
|
|
* When implementing fuzzy search:
|
|
* 1. Implement the ~= (fuzzy exact match) operator with edit distance <= 2
|
|
* 2. Implement the ~* (fuzzy contains) operator for substring matching with typos
|
|
* 3. Ensure minimum token length of 3 characters for fuzzy matching
|
|
* 4. Implement diacritic normalization
|
|
* 5. Un-skip these tests and verify they all pass
|
|
*/
|
|
describe("Fuzzy Search - Comprehensive Tests", () => {
|
|
let rootNote: NoteBuilder;
|
|
|
|
beforeEach(() => {
|
|
becca.reset();
|
|
|
|
rootNote = new NoteBuilder(new BNote({ noteId: "root", title: "root", type: "text" }));
|
|
new BBranch({
|
|
branchId: "none_root",
|
|
noteId: "root",
|
|
parentNoteId: "none",
|
|
notePosition: 10
|
|
});
|
|
});
|
|
|
|
describe("Fuzzy Exact Match (~=)", () => {
|
|
it.skip("should find exact matches with ~= operator (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// These tests are ready to validate fuzzy search when the feature is added
|
|
// See search.md lines 72-86 for fuzzy search specification
|
|
rootNote
|
|
.child(note("Trilium Notes"))
|
|
.child(note("Another Note"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~= Trilium", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Trilium Notes")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should find matches with 1 character edit distance (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Trilium Notes"))
|
|
.child(note("Project Documentation"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "trilim" is 1 edit away from "trilium" (missing 'u')
|
|
const results = searchService.findResultsWithQuery("note.title ~= trilim", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Trilium Notes")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should find matches with 2 character edit distance (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Development Guide"))
|
|
.child(note("User Manual"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "develpment" is 2 edits away from "development" (missing 'o', wrong 'p')
|
|
const results = searchService.findResultsWithQuery("note.title ~= develpment", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Development Guide")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should NOT find matches exceeding 2 character edit distance (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Documentation"))
|
|
.child(note("Guide"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "documnttn" is 3+ edits away from "documentation"
|
|
const results = searchService.findResultsWithQuery("note.title ~= documnttn", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Documentation")).toBeFalsy();
|
|
});
|
|
|
|
it.skip("should handle substitution edit type (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Programming Guide"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "programing" has one substitution (double 'm' -> single 'm')
|
|
const results = searchService.findResultsWithQuery("note.title ~= programing", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Programming Guide")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle insertion edit type (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Analysis Report"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "anaylsis" is missing 'l' (deletion from search term = insertion to match)
|
|
const results = searchService.findResultsWithQuery("note.title ~= anaylsis", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Analysis Report")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle deletion edit type (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Test Document"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "tesst" has extra 's' (insertion from search term = deletion to match)
|
|
const results = searchService.findResultsWithQuery("note.title ~= tesst", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Test Document")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle multiple edit types in one search (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Statistical Analysis"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "statsitcal" has multiple edits: missing 'i', transposed 'ti' -> 'it'
|
|
const results = searchService.findResultsWithQuery("note.title ~= statsitcal", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Statistical Analysis")).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("Fuzzy Contains (~*)", () => {
|
|
it.skip("should find substring matches with ~* operator (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Programming in JavaScript"))
|
|
.child(note("Python Tutorial"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~* program", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Programming in JavaScript")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should find fuzzy substring with typos (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Development Guide"))
|
|
.child(note("Testing Manual"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "develpment" is fuzzy match for "development"
|
|
const results = searchService.findResultsWithQuery("note.content ~* develpment", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it.skip("should match variations of programmer/programming (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Programmer Guide"))
|
|
.child(note("Programming Tutorial"))
|
|
.child(note("Programs Overview"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "progra" should fuzzy match all variations
|
|
const results = searchService.findResultsWithQuery("note.title ~* progra", searchContext);
|
|
|
|
expect(results.length).toBe(3);
|
|
});
|
|
|
|
it.skip("should not match if substring is too different (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Documentation Guide"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "xyz" is completely different
|
|
const results = searchService.findResultsWithQuery("note.title ~* xyz", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Documentation Guide")).toBeFalsy();
|
|
});
|
|
});
|
|
|
|
describe("Minimum Token Length Validation", () => {
|
|
it.skip("should not apply fuzzy matching to tokens < 3 characters (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Go Programming"))
|
|
.child(note("To Do List"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "go" is only 2 characters, should use exact matching only
|
|
const results = searchService.findResultsWithQuery("note.title ~= go", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Go Programming")).toBeTruthy();
|
|
// Should NOT fuzzy match "To" even though it's similar
|
|
expect(results.length).toBe(1);
|
|
});
|
|
|
|
it.skip("should apply fuzzy matching to tokens >= 3 characters (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Java Programming"))
|
|
.child(note("JavaScript Tutorial"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "jav" is 3 characters, fuzzy matching should work
|
|
const results = searchService.findResultsWithQuery("note.title ~* jav", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThanOrEqual(1);
|
|
});
|
|
|
|
it.skip("should handle exact 3 character tokens (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("API Documentation"))
|
|
.child(note("APP Development"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "api" (3 chars) should fuzzy match "app" (1 edit distance)
|
|
const results = searchService.findResultsWithQuery("note.title ~= api", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThanOrEqual(1);
|
|
});
|
|
});
|
|
|
|
describe("Diacritic Normalization", () => {
|
|
it.skip("should match café with cafe (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Paris Café Guide"))
|
|
.child(note("Coffee Shop"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Search without diacritic should find note with diacritic
|
|
const results = searchService.findResultsWithQuery("note.title ~* cafe", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Paris Café Guide")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should match naïve with naive (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Naïve Algorithm"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~* naive", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Naïve Algorithm")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should match résumé with resume (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Résumé Template"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~* resume", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Résumé Template")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should normalize various diacritics (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Zürich Travel"))
|
|
.child(note("São Paulo Guide"))
|
|
.child(note("Łódź History"));
|
|
|
|
const searchContext = new SearchContext();
|
|
|
|
// Test each normalized version
|
|
const zurich = searchService.findResultsWithQuery("note.title ~* zurich", searchContext);
|
|
expect(findNoteByTitle(zurich, "Zürich Travel")).toBeTruthy();
|
|
|
|
const sao = searchService.findResultsWithQuery("note.title ~* sao", searchContext);
|
|
expect(findNoteByTitle(sao, "São Paulo Guide")).toBeTruthy();
|
|
|
|
const lodz = searchService.findResultsWithQuery("note.title ~* lodz", searchContext);
|
|
expect(findNoteByTitle(lodz, "Łódź History")).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("Fuzzy Search in Different Contexts", () => {
|
|
describe("Title Fuzzy Search", () => {
|
|
it.skip("should perform fuzzy search on note titles (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Trilium Documentation"))
|
|
.child(note("Project Overview"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in "trilium"
|
|
const results = searchService.findResultsWithQuery("note.title ~= trilim", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Trilium Documentation")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle multiple word titles (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Advanced Programming Techniques"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in "programming"
|
|
const results = searchService.findResultsWithQuery("note.title ~* programing", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Advanced Programming Techniques")).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("Content Fuzzy Search", () => {
|
|
it.skip("should perform fuzzy search on note content (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
const testNote = note("Technical Guide");
|
|
testNote.note.setContent("This document contains programming information");
|
|
rootNote.child(testNote);
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in "programming"
|
|
const results = searchService.findResultsWithQuery("note.content ~* programing", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Technical Guide")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle content with multiple potential matches (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
const testNote = note("Development Basics");
|
|
testNote.note.setContent("Learn about development, testing, and deployment");
|
|
rootNote.child(testNote);
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in "testing"
|
|
const results = searchService.findResultsWithQuery("note.content ~* testng", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Development Basics")).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("Label Fuzzy Search", () => {
|
|
it.skip("should perform fuzzy search on label names (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Book Note").label("category", "programming"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in label name
|
|
const results = searchService.findResultsWithQuery("#catgory ~= programming", searchContext);
|
|
|
|
// Note: This depends on fuzzyAttributeSearch being enabled
|
|
const fuzzyContext = new SearchContext({ fuzzyAttributeSearch: true });
|
|
const fuzzyResults = searchService.findResultsWithQuery("#catgory", fuzzyContext);
|
|
expect(fuzzyResults.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it.skip("should perform fuzzy search on label values (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Tech Book").label("subject", "programming"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in label value
|
|
const results = searchService.findResultsWithQuery("#subject ~= programing", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Tech Book")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle labels with multiple values (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Book 1").label("topic", "development"))
|
|
.child(note("Book 2").label("topic", "testing"))
|
|
.child(note("Book 3").label("topic", "deployment"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Fuzzy search for "develpment"
|
|
const results = searchService.findResultsWithQuery("#topic ~= develpment", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "Book 1")).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("Relation Fuzzy Search", () => {
|
|
it.skip("should perform fuzzy search on relation targets (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
const author = note("J.R.R. Tolkien");
|
|
rootNote
|
|
.child(author)
|
|
.child(note("The Hobbit").relation("author", author.note));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in "Tolkien"
|
|
const results = searchService.findResultsWithQuery("~author.title ~= Tolkein", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "The Hobbit")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle relation chains with fuzzy matching (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
const author = note("Author Name");
|
|
const publisher = note("Publishing House");
|
|
author.relation("publisher", publisher.note);
|
|
|
|
rootNote
|
|
.child(publisher)
|
|
.child(author)
|
|
.child(note("Book Title").relation("author", author.note));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in "publisher"
|
|
const results = searchService.findResultsWithQuery("~author.relations.publsher", searchContext);
|
|
|
|
// Relation chains with typos may not match - verify graceful handling
|
|
expect(results).toBeDefined();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Progressive Search Integration", () => {
|
|
it.skip("should prioritize exact matches over fuzzy matches (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Analysis Report")) // Exact match
|
|
.child(note("Anaylsis Document")) // Fuzzy match
|
|
.child(note("Data Analysis")); // Exact match
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("analysis", searchContext);
|
|
|
|
// Should find both exact and fuzzy matches
|
|
expect(results.length).toBe(3);
|
|
|
|
// Get titles in order
|
|
const titles = results.map(r => becca.notes[r.noteId].title);
|
|
|
|
// Find positions
|
|
const exactIndices = titles.map((t, i) =>
|
|
t.toLowerCase().includes("analysis") ? i : -1
|
|
).filter(i => i !== -1);
|
|
|
|
const fuzzyIndices = titles.map((t, i) =>
|
|
t.includes("Anaylsis") ? i : -1
|
|
).filter(i => i !== -1);
|
|
|
|
// All exact matches should come before fuzzy matches
|
|
if (exactIndices.length > 0 && fuzzyIndices.length > 0) {
|
|
expect(Math.max(...exactIndices)).toBeLessThan(Math.min(...fuzzyIndices));
|
|
}
|
|
});
|
|
|
|
it.skip("should only activate fuzzy search when exact matches are insufficient (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Test One"))
|
|
.child(note("Test Two"))
|
|
.child(note("Test Three"))
|
|
.child(note("Test Four"))
|
|
.child(note("Test Five"))
|
|
.child(note("Tset Six")); // Typo
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("test", searchContext);
|
|
|
|
// With 5 exact matches, fuzzy should not be needed
|
|
// The typo note might not be included
|
|
expect(results.length).toBeGreaterThanOrEqual(5);
|
|
});
|
|
});
|
|
|
|
describe("Fuzzy Score Calculation and Ranking", () => {
|
|
it.skip("should score fuzzy matches lower than exact matches (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Programming Guide")) // Exact
|
|
.child(note("Programing Tutorial")); // Fuzzy
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("programming", searchContext);
|
|
|
|
expect(results.length).toBe(2);
|
|
|
|
const exactResult = results.find(r =>
|
|
becca.notes[r.noteId].title === "Programming Guide"
|
|
);
|
|
const fuzzyResult = results.find(r =>
|
|
becca.notes[r.noteId].title === "Programing Tutorial"
|
|
);
|
|
|
|
expect(exactResult).toBeTruthy();
|
|
expect(fuzzyResult).toBeTruthy();
|
|
expect(exactResult!.score).toBeGreaterThan(fuzzyResult!.score);
|
|
});
|
|
|
|
it.skip("should rank by edit distance within fuzzy matches (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Test Document")) // Exact
|
|
.child(note("Tst Document")) // 1 edit
|
|
.child(note("Tset Document")); // 1 edit (different)
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("test", searchContext);
|
|
|
|
// All should be found
|
|
expect(results.length).toBeGreaterThanOrEqual(3);
|
|
|
|
// Exact match should have highest score
|
|
const scores = results.map(r => ({
|
|
title: becca.notes[r.noteId].title,
|
|
score: r.score
|
|
}));
|
|
|
|
const exactScore = scores.find(s => s.title === "Test Document")?.score;
|
|
const fuzzy1Score = scores.find(s => s.title === "Tst Document")?.score;
|
|
const fuzzy2Score = scores.find(s => s.title === "Tset Document")?.score;
|
|
|
|
if (exactScore && fuzzy1Score) {
|
|
expect(exactScore).toBeGreaterThan(fuzzy1Score);
|
|
}
|
|
});
|
|
|
|
it.skip("should handle multiple fuzzy matches in same note (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
const testNote = note("Programming and Development");
|
|
testNote.note.setContent("Learn programing and developmnt techniques");
|
|
rootNote.child(testNote);
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("programming development", searchContext);
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(findNoteByTitle(results, "Programming and Development")).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("Edge Cases", () => {
|
|
it.skip("should handle empty search strings (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Some Note"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~= ", searchContext);
|
|
|
|
// Empty search should return no results or all results depending on implementation
|
|
expect(results).toBeDefined();
|
|
});
|
|
|
|
it.skip("should handle special characters in fuzzy search (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("C++ Programming"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~* c++", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "C++ Programming")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle numbers in fuzzy search (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Project 2024 Overview"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// Typo in number
|
|
const results = searchService.findResultsWithQuery("note.title ~* 2023", searchContext);
|
|
|
|
// Should find fuzzy match for similar number
|
|
expect(findNoteByTitle(results, "Project 2024 Overview")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle very long search terms (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Short Title"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const longSearch = "a".repeat(100);
|
|
const results = searchService.findResultsWithQuery(`note.title ~= ${longSearch}`, searchContext);
|
|
|
|
// Should not crash, should return empty results
|
|
expect(results).toBeDefined();
|
|
expect(results.length).toBe(0);
|
|
});
|
|
|
|
it.skip("should handle Unicode characters (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("🚀 Rocket Science"))
|
|
.child(note("日本語 Japanese"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results1 = searchService.findResultsWithQuery("note.title ~* rocket", searchContext);
|
|
expect(findNoteByTitle(results1, "🚀 Rocket Science")).toBeTruthy();
|
|
|
|
const results2 = searchService.findResultsWithQuery("note.title ~* japanese", searchContext);
|
|
expect(findNoteByTitle(results2, "日本語 Japanese")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle case sensitivity correctly (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("PROGRAMMING GUIDE"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~* programming", searchContext);
|
|
|
|
expect(findNoteByTitle(results, "PROGRAMMING GUIDE")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should fuzzy match when edit distance is exactly at boundary (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Test Document"));
|
|
|
|
const searchContext = new SearchContext();
|
|
// "txx" is exactly 2 edits from "test" (substitute e->x, substitute s->x)
|
|
const results = searchService.findResultsWithQuery("note.title ~= txx", searchContext);
|
|
|
|
// Should still match at edit distance = 2
|
|
expect(findNoteByTitle(results, "Test Document")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should handle whitespace in search terms (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Multiple Word Title"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~* 'multiple word'", searchContext);
|
|
|
|
// Extra spaces should be handled
|
|
expect(results.length).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
|
|
describe("Fuzzy Matching with Operators", () => {
|
|
it.skip("should work with OR operator (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Programming Guide"))
|
|
.child(note("Testing Manual"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery(
|
|
"note.title ~* programing OR note.title ~* testng",
|
|
searchContext
|
|
);
|
|
|
|
expect(results.length).toBe(2);
|
|
});
|
|
|
|
it.skip("should work with AND operator (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote.child(note("Advanced Programming Techniques"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery(
|
|
"note.title ~* programing AND note.title ~* techniqes",
|
|
searchContext
|
|
);
|
|
|
|
expect(findNoteByTitle(results, "Advanced Programming Techniques")).toBeTruthy();
|
|
});
|
|
|
|
it.skip("should work with NOT operator (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
rootNote
|
|
.child(note("Programming Guide"))
|
|
.child(note("Testing Guide"));
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery(
|
|
"note.title ~* guide AND not(note.title ~* testing)",
|
|
searchContext
|
|
);
|
|
|
|
expect(findNoteByTitle(results, "Programming Guide")).toBeTruthy();
|
|
expect(findNoteByTitle(results, "Testing Guide")).toBeFalsy();
|
|
});
|
|
});
|
|
|
|
describe("Performance and Limits", () => {
|
|
it.skip("should handle moderate dataset efficiently (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
// Create multiple notes with variations
|
|
for (let i = 0; i < 20; i++) {
|
|
rootNote.child(note(`Programming Example ${i}`));
|
|
}
|
|
|
|
const searchContext = new SearchContext();
|
|
const startTime = Date.now();
|
|
const results = searchService.findResultsWithQuery("note.title ~* programing", searchContext);
|
|
const endTime = Date.now();
|
|
|
|
expect(results.length).toBeGreaterThan(0);
|
|
expect(endTime - startTime).toBeLessThan(1000); // Should complete in under 1 second
|
|
});
|
|
|
|
it.skip("should cap fuzzy results to prevent excessive matching (fuzzy operators not yet implemented)", () => {
|
|
// TODO: Fuzzy search operators (~= and ~*) are not implemented in the search engine
|
|
// This test validates fuzzy search behavior per search.md lines 72-86
|
|
// Test is ready to run once fuzzy search feature is added to the search implementation
|
|
|
|
// Create many similar notes
|
|
for (let i = 0; i < 50; i++) {
|
|
rootNote.child(note(`Test Document ${i}`));
|
|
}
|
|
|
|
const searchContext = new SearchContext();
|
|
const results = searchService.findResultsWithQuery("note.title ~* tst", searchContext);
|
|
|
|
// Should return results but with reasonable limits
|
|
expect(results).toBeDefined();
|
|
expect(results.length).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
});
|