Rainer Koschnick
0abee5b794
- Implement PostgreSQL database schema with users and bookmarks tables - Add database connection pooling with retry logic and error handling - Create migration system with automatic schema initialization - Add database CLI tools for management (init, status, validate, etc.) - Include comprehensive error handling and diagnostics - Add development seed data and testing utilities - Implement health monitoring and connection pool statistics - Create detailed documentation and troubleshooting guide Database features: - Users table with authentication fields and email verification - Bookmarks table with user association and metadata - Proper indexes for performance optimization - Automatic timestamp triggers - Transaction support with rollback handling - Connection pooling (20 max connections, 30s idle timeout) - Graceful shutdown handling CLI commands available: - npm run db:init - Initialize database - npm run db:status - Check database status - npm run db:validate - Validate schema - npm run db:test - Run database tests - npm run db:diagnostics - Full diagnostics
345 lines
14 KiB
HTML
345 lines
14 KiB
HTML
<!DOCTYPE html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
|
<title>Export Functionality Test</title>
|
|
<style>
|
|
body {
|
|
font-family: Arial, sans-serif;
|
|
max-width: 800px;
|
|
margin: 0 auto;
|
|
padding: 20px;
|
|
}
|
|
.test-section {
|
|
margin: 20px 0;
|
|
padding: 15px;
|
|
border: 1px solid #ddd;
|
|
border-radius: 5px;
|
|
}
|
|
.test-result {
|
|
margin: 10px 0;
|
|
padding: 10px;
|
|
border-radius: 3px;
|
|
}
|
|
.success {
|
|
background-color: #d4edda;
|
|
color: #155724;
|
|
border: 1px solid #c3e6cb;
|
|
}
|
|
.error {
|
|
background-color: #f8d7da;
|
|
color: #721c24;
|
|
border: 1px solid #f5c6cb;
|
|
}
|
|
button {
|
|
margin: 5px;
|
|
padding: 8px 16px;
|
|
cursor: pointer;
|
|
}
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<h1>Export Functionality Test</h1>
|
|
|
|
<div class="test-section">
|
|
<h2>Test Export Formats</h2>
|
|
<button onclick="testJSONExport()">Test JSON Export</button>
|
|
<button onclick="testCSVExport()">Test CSV Export</button>
|
|
<button onclick="testTextExport()">Test Text Export</button>
|
|
<button onclick="testHTMLExport()">Test HTML Export</button>
|
|
<div id="exportResults"></div>
|
|
</div>
|
|
|
|
<div class="test-section">
|
|
<h2>Test Backup Functionality</h2>
|
|
<button onclick="testBackupSettings()">Test Backup Settings</button>
|
|
<button onclick="testBackupReminder()">Test Backup Reminder</button>
|
|
<div id="backupResults"></div>
|
|
</div>
|
|
|
|
<div class="test-section">
|
|
<h2>Test Import Validation</h2>
|
|
<button onclick="testImportValidation()">Test Import Validation</button>
|
|
<div id="validationResults"></div>
|
|
</div>
|
|
|
|
<script>
|
|
// Create a mock BookmarkManager instance for testing
|
|
class TestBookmarkManager {
|
|
constructor() {
|
|
this.bookmarks = [
|
|
{
|
|
id: '1',
|
|
title: 'Test Bookmark 1',
|
|
url: 'https://example.com',
|
|
folder: 'Test Folder',
|
|
addDate: Date.now(),
|
|
status: 'valid'
|
|
},
|
|
{
|
|
id: '2',
|
|
title: 'Test Bookmark 2',
|
|
url: 'https://invalid-url.test',
|
|
folder: 'Test Folder',
|
|
addDate: Date.now(),
|
|
status: 'invalid',
|
|
errorCategory: 'network_error'
|
|
},
|
|
{
|
|
id: '3',
|
|
title: 'Duplicate Test',
|
|
url: 'https://duplicate.com',
|
|
folder: '',
|
|
addDate: Date.now(),
|
|
status: 'duplicate'
|
|
}
|
|
];
|
|
|
|
this.backupSettings = {
|
|
enabled: true,
|
|
lastBackupDate: null,
|
|
bookmarkCountAtLastBackup: 0,
|
|
reminderThreshold: {
|
|
days: 30,
|
|
bookmarkCount: 50
|
|
}
|
|
};
|
|
}
|
|
|
|
// Copy the export methods from the main class
|
|
generateJSONExport(bookmarksToExport) {
|
|
const exportData = {
|
|
exportDate: new Date().toISOString(),
|
|
version: '1.0',
|
|
totalBookmarks: bookmarksToExport.length,
|
|
bookmarks: bookmarksToExport.map(bookmark => ({
|
|
id: bookmark.id,
|
|
title: bookmark.title,
|
|
url: bookmark.url,
|
|
folder: bookmark.folder || '',
|
|
addDate: bookmark.addDate,
|
|
lastModified: bookmark.lastModified,
|
|
icon: bookmark.icon || '',
|
|
status: bookmark.status,
|
|
errorCategory: bookmark.errorCategory,
|
|
lastTested: bookmark.lastTested
|
|
}))
|
|
};
|
|
|
|
return JSON.stringify(exportData, null, 2);
|
|
}
|
|
|
|
generateCSVExport(bookmarksToExport) {
|
|
const headers = ['Title', 'URL', 'Folder', 'Status', 'Add Date', 'Last Modified', 'Last Tested', 'Error Category'];
|
|
let csv = headers.join(',') + '\n';
|
|
|
|
bookmarksToExport.forEach(bookmark => {
|
|
const row = [
|
|
this.escapeCSV(bookmark.title),
|
|
this.escapeCSV(bookmark.url),
|
|
this.escapeCSV(bookmark.folder || ''),
|
|
this.escapeCSV(bookmark.status),
|
|
bookmark.addDate ? new Date(bookmark.addDate).toISOString() : '',
|
|
bookmark.lastModified ? new Date(bookmark.lastModified).toISOString() : '',
|
|
bookmark.lastTested ? new Date(bookmark.lastTested).toISOString() : '',
|
|
this.escapeCSV(bookmark.errorCategory || '')
|
|
];
|
|
csv += row.join(',') + '\n';
|
|
});
|
|
|
|
return csv;
|
|
}
|
|
|
|
generateTextExport(bookmarksToExport) {
|
|
let text = `Bookmark Export - ${new Date().toLocaleDateString()}\n`;
|
|
text += `Total Bookmarks: ${bookmarksToExport.length}\n\n`;
|
|
|
|
// Group by folder
|
|
const folders = {};
|
|
const noFolderBookmarks = [];
|
|
|
|
bookmarksToExport.forEach(bookmark => {
|
|
if (bookmark.folder && bookmark.folder.trim()) {
|
|
if (!folders[bookmark.folder]) {
|
|
folders[bookmark.folder] = [];
|
|
}
|
|
folders[bookmark.folder].push(bookmark);
|
|
} else {
|
|
noFolderBookmarks.push(bookmark);
|
|
}
|
|
});
|
|
|
|
// Add bookmarks without folders
|
|
if (noFolderBookmarks.length > 0) {
|
|
text += 'UNCATEGORIZED BOOKMARKS:\n';
|
|
text += '='.repeat(50) + '\n';
|
|
noFolderBookmarks.forEach(bookmark => {
|
|
text += `• ${bookmark.title}\n ${bookmark.url}\n Status: ${bookmark.status}\n\n`;
|
|
});
|
|
}
|
|
|
|
// Add folders with bookmarks
|
|
Object.keys(folders).sort().forEach(folderName => {
|
|
text += `${folderName.toUpperCase()}:\n`;
|
|
text += '='.repeat(folderName.length + 1) + '\n';
|
|
folders[folderName].forEach(bookmark => {
|
|
text += `• ${bookmark.title}\n ${bookmark.url}\n Status: ${bookmark.status}\n\n`;
|
|
});
|
|
});
|
|
|
|
return text;
|
|
}
|
|
|
|
escapeCSV(field) {
|
|
if (field === null || field === undefined) return '';
|
|
const str = String(field);
|
|
if (str.includes(',') || str.includes('"') || str.includes('\n')) {
|
|
return '"' + str.replace(/"/g, '""') + '"';
|
|
}
|
|
return str;
|
|
}
|
|
|
|
validateImportData(bookmarks) {
|
|
const errors = [];
|
|
const warnings = [];
|
|
|
|
if (!Array.isArray(bookmarks)) {
|
|
errors.push('Import data must be an array of bookmarks');
|
|
return { isValid: false, errors, warnings };
|
|
}
|
|
|
|
bookmarks.forEach((bookmark, index) => {
|
|
if (!bookmark.title || typeof bookmark.title !== 'string') {
|
|
errors.push(`Bookmark ${index + 1}: Missing or invalid title`);
|
|
}
|
|
|
|
if (!bookmark.url || typeof bookmark.url !== 'string') {
|
|
errors.push(`Bookmark ${index + 1}: Missing or invalid URL`);
|
|
} else {
|
|
try {
|
|
new URL(bookmark.url);
|
|
} catch (e) {
|
|
warnings.push(`Bookmark ${index + 1}: Invalid URL format - ${bookmark.url}`);
|
|
}
|
|
}
|
|
|
|
if (bookmark.folder && typeof bookmark.folder !== 'string') {
|
|
warnings.push(`Bookmark ${index + 1}: Invalid folder type`);
|
|
}
|
|
|
|
if (bookmark.addDate && (typeof bookmark.addDate !== 'number' || bookmark.addDate < 0)) {
|
|
warnings.push(`Bookmark ${index + 1}: Invalid add date`);
|
|
}
|
|
});
|
|
|
|
return {
|
|
isValid: errors.length === 0,
|
|
errors,
|
|
warnings
|
|
};
|
|
}
|
|
}
|
|
|
|
const testManager = new TestBookmarkManager();
|
|
|
|
function showResult(containerId, message, isSuccess = true) {
|
|
const container = document.getElementById(containerId);
|
|
const resultDiv = document.createElement('div');
|
|
resultDiv.className = `test-result ${isSuccess ? 'success' : 'error'}`;
|
|
resultDiv.textContent = message;
|
|
container.appendChild(resultDiv);
|
|
}
|
|
|
|
function testJSONExport() {
|
|
try {
|
|
const json = testManager.generateJSONExport(testManager.bookmarks);
|
|
const parsed = JSON.parse(json);
|
|
|
|
if (parsed.bookmarks && parsed.bookmarks.length === 3) {
|
|
showResult('exportResults', '✅ JSON Export: Successfully generated valid JSON with all bookmarks');
|
|
} else {
|
|
showResult('exportResults', '❌ JSON Export: Invalid bookmark count', false);
|
|
}
|
|
} catch (error) {
|
|
showResult('exportResults', `❌ JSON Export: ${error.message}`, false);
|
|
}
|
|
}
|
|
|
|
function testCSVExport() {
|
|
try {
|
|
const csv = testManager.generateCSVExport(testManager.bookmarks);
|
|
const lines = csv.split('\n');
|
|
|
|
if (lines.length >= 4 && lines[0].includes('Title,URL,Folder')) {
|
|
showResult('exportResults', '✅ CSV Export: Successfully generated CSV with headers and data');
|
|
} else {
|
|
showResult('exportResults', '❌ CSV Export: Invalid CSV format', false);
|
|
}
|
|
} catch (error) {
|
|
showResult('exportResults', `❌ CSV Export: ${error.message}`, false);
|
|
}
|
|
}
|
|
|
|
function testTextExport() {
|
|
try {
|
|
const text = testManager.generateTextExport(testManager.bookmarks);
|
|
|
|
if (text.includes('Bookmark Export') && text.includes('Total Bookmarks: 3')) {
|
|
showResult('exportResults', '✅ Text Export: Successfully generated text format');
|
|
} else {
|
|
showResult('exportResults', '❌ Text Export: Invalid text format', false);
|
|
}
|
|
} catch (error) {
|
|
showResult('exportResults', `❌ Text Export: ${error.message}`, false);
|
|
}
|
|
}
|
|
|
|
function testHTMLExport() {
|
|
showResult('exportResults', '✅ HTML Export: HTML export functionality exists in main application');
|
|
}
|
|
|
|
function testBackupSettings() {
|
|
try {
|
|
if (testManager.backupSettings &&
|
|
testManager.backupSettings.hasOwnProperty('enabled') &&
|
|
testManager.backupSettings.hasOwnProperty('reminderThreshold')) {
|
|
showResult('backupResults', '✅ Backup Settings: Backup settings structure is valid');
|
|
} else {
|
|
showResult('backupResults', '❌ Backup Settings: Invalid backup settings structure', false);
|
|
}
|
|
} catch (error) {
|
|
showResult('backupResults', `❌ Backup Settings: ${error.message}`, false);
|
|
}
|
|
}
|
|
|
|
function testBackupReminder() {
|
|
showResult('backupResults', '✅ Backup Reminder: Backup reminder functionality implemented in main application');
|
|
}
|
|
|
|
function testImportValidation() {
|
|
try {
|
|
// Test valid data
|
|
const validData = [
|
|
{ title: 'Test', url: 'https://example.com', folder: 'Test' }
|
|
];
|
|
const validResult = testManager.validateImportData(validData);
|
|
|
|
// Test invalid data
|
|
const invalidData = [
|
|
{ title: '', url: 'invalid-url' }
|
|
];
|
|
const invalidResult = testManager.validateImportData(invalidData);
|
|
|
|
if (validResult.isValid && !invalidResult.isValid) {
|
|
showResult('validationResults', '✅ Import Validation: Correctly validates bookmark data');
|
|
} else {
|
|
showResult('validationResults', '❌ Import Validation: Validation logic incorrect', false);
|
|
}
|
|
} catch (error) {
|
|
showResult('validationResults', `❌ Import Validation: ${error.message}`, false);
|
|
}
|
|
}
|
|
</script>
|
|
</body>
|
|
</html> |