@real1ty-obsidian-plugins/utils 2.3.0 → 2.4.0

package/src/string/string.ts

@@ -0,0 +1,26 @@
+export const capitalize = (str: string): string => {
+	if (!str) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+export const generateDuplicatedTitle = (originalTitle: string): string => {
+	// Check if title already has a counter pattern like " (2)", " - Copy", etc.
+	const counterMatch = originalTitle.match(/^(.*?)(?:\s*\((\d+)\)|\s*-?\s*Copy(?:\s*(\d+))?)$/);
+
+	if (counterMatch) {
+		const baseName = counterMatch[1];
+		const existingCounter = counterMatch[2] || counterMatch[3];
+		const nextCounter = existingCounter ? parseInt(existingCounter, 10) + 1 : 2;
+		return `${baseName} (${nextCounter})`;
+	} else {
+		return `${originalTitle} (2)`;
+	}
+};
+
+export const pluralize = (count: number): string => {
+	return count === 1 ? "" : "s";
+};
+
+export const getWeekDirection = (weeks: number): "next" | "previous" => {
+	return weeks > 0 ? "next" : "previous";
+};

package/src/testing/index.ts

@@ -0,0 +1,23 @@
+export * from "./mocks/obsidian";
+// Re-export commonly used combinations
+export {
+	createMockApp,
+	createMockFile,
+	createMockFileCache,
+	Modal,
+	Notice,
+	Plugin,
+	PluginSettingTab,
+	Setting,
+	TFile,
+} from "./mocks/obsidian";
+export * from "./mocks/utils";
+export {
+	mockFileOperations,
+	mockLinkParser,
+	resetAllMocks,
+	setupDefaultMockImplementations,
+	setupMockImplementation,
+	setupMockReturnValue,
+	verifyMockCalls,
+} from "./mocks/utils";

package/src/testing/mocks/obsidian.ts

@@ -0,0 +1,331 @@
+import { vi } from "vitest";
+
+// Base Plugin class mock
+export class Plugin {
+	app: any;
+	manifest: any;
+	settings: any;
+
+	constructor(app: any, manifest: any) {
+		this.app = app;
+		this.manifest = manifest;
+	}
+
+	// Core plugin methods
+	addSettingTab = vi.fn();
+	registerEvent = vi.fn();
+	loadData = vi.fn().mockResolvedValue({});
+	saveData = vi.fn().mockResolvedValue(undefined);
+	onload = vi.fn();
+	onunload = vi.fn();
+
+	// UI methods
+	addRibbonIcon = vi.fn();
+	addStatusBarItem = vi.fn();
+	addCommand = vi.fn();
+	removeCommand = vi.fn();
+
+	// Event methods
+	registerDomEvent = vi.fn();
+	registerCodeMirror = vi.fn();
+	registerEditorExtension = vi.fn();
+	registerMarkdownPostProcessor = vi.fn();
+	registerMarkdownCodeBlockProcessor = vi.fn();
+	registerObsidianProtocolHandler = vi.fn();
+	registerEditorSuggest = vi.fn();
+	registerHoverLinkSource = vi.fn();
+
+	// Interval methods
+	registerInterval = vi.fn();
+
+	// View and extension methods
+	registerView = vi.fn();
+	registerExtensions = vi.fn();
+
+	// Lifecycle methods
+	onUserEnable = vi.fn();
+	load = vi.fn();
+	unload = vi.fn();
+
+	// Other methods
+	addChild = vi.fn();
+	removeChild = vi.fn();
+	register = vi.fn();
+}
+
+// PluginSettingTab mock
+export class PluginSettingTab {
+	app: any;
+	plugin: any;
+	containerEl: HTMLElement;
+
+	constructor(app: any, plugin: any) {
+		this.app = app;
+		this.plugin = plugin;
+		this.containerEl = document.createElement("div");
+	}
+
+	display = vi.fn();
+}
+
+// ItemView mock
+export class ItemView {
+	app: any;
+	leaf: any;
+	containerEl: HTMLElement;
+
+	constructor(leaf: any) {
+		this.leaf = leaf;
+		this.app = leaf?.app;
+		this.containerEl = document.createElement("div");
+	}
+
+	// Don't override onOpen/onClose - let subclasses implement them
+	// These methods are implemented by MountableView mixin
+
+	// Don't provide default implementations for these methods
+	// Let subclasses implement them
+	getViewType(): string {
+		return "mock-view";
+	}
+
+	getDisplayText(): string {
+		return "Mock View";
+	}
+
+	getIcon(): string {
+		return "mock-icon";
+	}
+
+	getState = vi.fn().mockReturnValue({});
+	setState = vi.fn().mockResolvedValue(undefined);
+}
+
+// Setting component mock
+export class Setting {
+	settingEl: HTMLElement;
+	nameEl: HTMLElement;
+	descEl: HTMLElement;
+	controlEl: HTMLElement;
+
+	constructor(_containerEl: HTMLElement) {
+		this.settingEl = document.createElement("div");
+		this.nameEl = document.createElement("div");
+		this.descEl = document.createElement("div");
+		this.controlEl = document.createElement("div");
+	}
+
+	setName = vi.fn().mockReturnThis();
+	setDesc = vi.fn().mockReturnThis();
+	addText = vi.fn().mockReturnThis();
+	addTextArea = vi.fn().mockReturnThis();
+}
+
+// TFolder mock
+export class TFolder {
+	path: string;
+	name: string;
+	children: any[];
+	vault: any;
+	parent: TFolder | null;
+
+	constructor(path: string) {
+		this.path = path;
+		this.name = path.split("/").pop() || "";
+		this.children = [];
+		this.vault = {};
+		this.parent = null;
+	}
+
+	isRoot(): boolean {
+		return this.path === "" || this.path === "/";
+	}
+}
+
+// TFile mock with full interface
+export class TFile {
+	path: string;
+	name: string;
+	basename: string;
+	extension: string;
+	stat: any;
+	vault: any;
+	parent: TFolder | null;
+
+	constructor(path: string, parentPath?: string) {
+		this.path = path;
+		this.name = path.split("/").pop() || "";
+		this.basename = this.name.replace(/\.[^/.]+$/, ""); // Remove extension
+		this.extension = path.split(".").pop() || "md";
+		this.stat = {};
+		this.vault = {};
+
+		// Set parent based on path or explicit parentPath
+		if (parentPath !== undefined) {
+			this.parent = parentPath ? new TFolder(parentPath) : null;
+		} else {
+			// Derive parent from path
+			const lastSlash = path.lastIndexOf("/");
+			if (lastSlash > 0) {
+				this.parent = new TFolder(path.substring(0, lastSlash));
+			} else {
+				this.parent = null;
+			}
+		}
+	}
+}
+
+// Modal mock
+export class Modal {
+	app: any;
+	containerEl: HTMLElement;
+	titleEl: HTMLElement;
+	contentEl: HTMLElement;
+
+	constructor(app: any) {
+		this.app = app;
+		this.containerEl = document.createElement("div");
+		this.titleEl = document.createElement("div");
+		this.contentEl = document.createElement("div");
+	}
+
+	open = vi.fn();
+	close = vi.fn();
+	onOpen = vi.fn();
+	onClose = vi.fn();
+}
+
+// Notice mock
+export class Notice {
+	constructor(message: string) {
+		console.log(`Notice: ${message}`);
+	}
+}
+
+// MarkdownRenderer mock
+export const MarkdownRenderer = {
+	render: vi.fn().mockResolvedValue(undefined),
+};
+
+// Debounce function mock
+export function debounce<T extends (...args: any[]) => any>(
+	func: T,
+	wait: number,
+	immediate?: boolean
+): T {
+	let timeout: ReturnType<typeof setTimeout> | null = null;
+
+	return ((...args: Parameters<T>) => {
+		const later = () => {
+			timeout = null;
+			if (!immediate) func(...args);
+		};
+
+		const callNow = immediate && !timeout;
+
+		if (timeout !== null) {
+			clearTimeout(timeout);
+		}
+
+		timeout = setTimeout(later, wait);
+
+		if (callNow) func(...args);
+	}) as T;
+}
+
+// normalizePath mock - simple path normalization for tests
+export function normalizePath(path: string): string {
+	// Basic normalization: replace backslashes with forward slashes
+	// and remove duplicate slashes
+	return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+
+// App mock
+export const App = vi.fn();
+
+// Mock interfaces for TypeScript
+export interface MockApp {
+	fileManager: {
+		processFrontMatter: ReturnType<typeof vi.fn>;
+	};
+	metadataCache: {
+		getFileCache: ReturnType<typeof vi.fn>;
+	};
+	vault: {
+		getAbstractFileByPath: ReturnType<typeof vi.fn>;
+		on: ReturnType<typeof vi.fn>;
+		read: ReturnType<typeof vi.fn>;
+		modify: ReturnType<typeof vi.fn>;
+		create: ReturnType<typeof vi.fn>;
+		delete: ReturnType<typeof vi.fn>;
+		rename: ReturnType<typeof vi.fn>;
+		getFiles: ReturnType<typeof vi.fn>;
+		getMarkdownFiles: ReturnType<typeof vi.fn>;
+		getFolderByPath: ReturnType<typeof vi.fn>;
+	};
+	workspace: {
+		getActiveFile: ReturnType<typeof vi.fn>;
+		on: ReturnType<typeof vi.fn>;
+	};
+}
+
+// Helper function to create a fully mocked app
+export function createMockApp(): MockApp {
+	return {
+		fileManager: {
+			processFrontMatter: vi.fn(),
+		},
+		metadataCache: {
+			getFileCache: vi.fn(),
+		},
+		vault: {
+			getAbstractFileByPath: vi.fn(),
+			on: vi.fn(),
+			read: vi.fn(),
+			modify: vi.fn(),
+			create: vi.fn(),
+			delete: vi.fn(),
+			rename: vi.fn(),
+			getFiles: vi.fn().mockReturnValue([]),
+			getMarkdownFiles: vi.fn().mockReturnValue([]),
+			getFolderByPath: vi.fn(),
+		},
+		workspace: {
+			getActiveFile: vi.fn(),
+			on: vi.fn(),
+		},
+	};
+}
+
+// Helper to create mock TFile instances
+export function createMockFile(
+	path: string,
+	options?: {
+		basename?: string;
+		parentPath?: string;
+		extension?: string;
+	}
+): TFile {
+	const file = new TFile(path, options?.parentPath);
+	if (options?.basename) {
+		file.basename = options.basename;
+	}
+	if (options?.extension) {
+		file.extension = options.extension;
+	}
+	return file;
+}
+
+// Helper to create mock file cache
+export function createMockFileCache(frontmatter?: Record<string, any>) {
+	return {
+		frontmatter: frontmatter || {},
+		frontmatterPosition: frontmatter ? { start: { line: 0 }, end: { line: 3 } } : null,
+		sections: [],
+		headings: [],
+		links: [],
+		embeds: [],
+		tags: [],
+		listItems: [],
+	};
+}

package/src/testing/mocks/utils.ts

@@ -0,0 +1,113 @@
+import { expect, vi } from "vitest";
+
+// File operations mocks
+export const mockFileOperations = {
+	arraysEqual: vi.fn(),
+	normalizeArray: vi.fn(),
+	createFileLink: vi.fn(),
+};
+
+// Link parser mocks
+export const mockLinkParser = {
+	extractFilePathFromLink: vi.fn(),
+};
+
+// Default mock implementations that match the actual behavior
+export function setupDefaultMockImplementations() {
+	// Set up file operations mocks
+	mockFileOperations.normalizeArray.mockImplementation((arr) =>
+		Array.isArray(arr) ? arr : arr ? [arr] : []
+	);
+
+	mockFileOperations.arraysEqual.mockImplementation(
+		(a, b) => JSON.stringify(a) === JSON.stringify(b)
+	);
+
+	mockFileOperations.createFileLink.mockImplementation((file) => {
+		if (!file) return "[[Unknown File]]";
+
+		const basename =
+			file.basename ||
+			file.path
+				?.split("/")
+				.pop()
+				?.replace(/\.[^/.]+$/, "") ||
+			"";
+		const parentPath = file.parent?.path;
+
+		if (!parentPath || parentPath === "/" || parentPath === "") {
+			return `[[${basename}]]`;
+		}
+
+		return `[[${parentPath}/${basename}|${basename}]]`;
+	});
+
+	// Set up link parser mocks
+	mockLinkParser.extractFilePathFromLink.mockImplementation((link) => {
+		if (!link || typeof link !== "string") return null;
+
+		// Handle text that contains a link
+		const linkMatch = link.match(/\[\[([^\]]+)\]\]/);
+		if (linkMatch) {
+			const content = linkMatch[1];
+			// Remove display name if present
+			const filePart = content.split("|")[0].trim();
+			if (!filePart) return null;
+
+			// Add .md extension if not present
+			return filePart.endsWith(".md") ? filePart : `${filePart}.md`;
+		}
+
+		return null;
+	});
+}
+
+// Reset all mocks
+export function resetAllMocks() {
+	Object.values(mockFileOperations).forEach((mock) => {
+		mock.mockReset();
+	});
+	Object.values(mockLinkParser).forEach((mock) => {
+		mock.mockReset();
+	});
+}
+
+// Helper to setup mocks with specific implementations
+export function setupMockImplementation(
+	mockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser,
+	implementation: (...args: any[]) => any
+) {
+	if (mockName in mockFileOperations) {
+		(mockFileOperations as any)[mockName].mockImplementation(implementation);
+	} else if (mockName in mockLinkParser) {
+		(mockLinkParser as any)[mockName].mockImplementation(implementation);
+	}
+}
+
+// Helper to setup mock return values
+export function setupMockReturnValue(
+	mockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser,
+	value: any
+) {
+	if (mockName in mockFileOperations) {
+		(mockFileOperations as any)[mockName].mockReturnValue(value);
+	} else if (mockName in mockLinkParser) {
+		(mockLinkParser as any)[mockName].mockReturnValue(value);
+	}
+}
+
+// Helper to verify mock calls
+export function verifyMockCalls(
+	mockName: keyof typeof mockFileOperations | keyof typeof mockLinkParser,
+	expectedCalls: any[][]
+) {
+	const mock =
+		mockName in mockFileOperations
+			? (mockFileOperations as any)[mockName]
+			: (mockLinkParser as any)[mockName];
+
+	expect(mock).toHaveBeenCalledTimes(expectedCalls.length);
+	expectedCalls.forEach((args, index) => {
+		expect(mock).toHaveBeenNthCalledWith(index + 1, ...args);
+	});
+}

package/src/testing/setup.ts

@@ -0,0 +1,19 @@
+import { vi } from "vitest";
+import { mockFileOperations, mockLinkParser } from "./mocks/utils";
+
+// Global test setup that can be imported once per test file
+export function setupTestEnvironment() {
+	// Mock the utils modules
+	vi.mock("@obsidian-plugins/utils/file-operations", () => mockFileOperations);
+	vi.mock("@obsidian-plugins/utils/link-parser", () => mockLinkParser);
+
+	// Mock any plugin-specific components
+	vi.mock("../src/components/settings-tab", () => ({
+		TreePropertiesManagerSettingTab: class MockSettingTab {},
+	}));
+
+	// Return cleanup function
+	return () => {
+		vi.clearAllMocks();
+	};
+}