feat: implement comprehensive backup and restore system with S3 support
- Add S3/MinIO storage adapter with multipart upload support - Implement database backup service for SQLite and PostgreSQL - Create backup manifest generator for tracking backup contents - Enhance backup service with S3 integration and incremental backups - Add restore service with safety measures and rollback capability - Create comprehensive test suite for all backup functionality - Add admin API endpoints for backup/restore management - Implement frontend UI with dashboard, configuration, and restore wizard - Add roadmap section to README with implemented backup feature This implementation provides: - Multiple backup destinations (local, rsync, S3/MinIO) - Intelligent change detection to minimize backup frequency - Full database backups with compression - Manifest-based restore with integrity validation - Pre-restore safety backups with rollback - Comprehensive error handling and monitoring - User-friendly admin interface 🤖 Generated with Claude Code Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,229 @@
|
||||
# Enhanced Backup System Test Suite
|
||||
|
||||
This directory contains comprehensive tests for the enhanced backup system with S3 support.
|
||||
|
||||
## Test Structure
|
||||
|
||||
### Unit Tests
|
||||
- `services/backupService.enhanced.test.js` - Unit tests for the enhanced backup service
|
||||
- Configuration management
|
||||
- S3 backup functionality
|
||||
- Manifest generation
|
||||
- Error handling and recovery
|
||||
- Backward compatibility (local and rsync)
|
||||
- Service lifecycle management
|
||||
|
||||
### Integration Tests
|
||||
- `integration/backup-s3.test.js` - Integration tests for S3 backups
|
||||
- Real S3/MinIO connection tests
|
||||
- Full backup process with actual files
|
||||
- Incremental backup verification
|
||||
- Manifest storage and retrieval
|
||||
- Error recovery scenarios
|
||||
|
||||
### Manual Integration Test Script
|
||||
- `../scripts/test-backup-integration.js` - Comprehensive manual testing script
|
||||
- Can test against MinIO, AWS S3, or any S3-compatible service
|
||||
- Tests all backup types (S3, local, rsync)
|
||||
- Performance testing with large files
|
||||
- Detailed progress reporting
|
||||
|
||||
## Running Tests
|
||||
|
||||
### Prerequisites
|
||||
|
||||
1. **For Unit Tests**: No special setup required, all dependencies are mocked.
|
||||
|
||||
2. **For Integration Tests**: Requires a running S3-compatible service (MinIO recommended)
|
||||
```bash
|
||||
# Start MinIO using Docker
|
||||
docker run -d \
|
||||
-p 9000:9000 \
|
||||
-p 9001:9001 \
|
||||
--name minio-test \
|
||||
-e MINIO_ROOT_USER=minioadmin \
|
||||
-e MINIO_ROOT_PASSWORD=minioadmin \
|
||||
minio/minio server /data --console-address ":9001"
|
||||
```
|
||||
|
||||
3. **Environment Variables** (for integration tests):
|
||||
```bash
|
||||
# Optional - defaults work with local MinIO
|
||||
export TEST_S3_ENDPOINT=http://localhost:9000
|
||||
export TEST_S3_ACCESS_KEY=minioadmin
|
||||
export TEST_S3_SECRET_KEY=minioadmin
|
||||
|
||||
# Skip S3 tests if no S3 service available
|
||||
export SKIP_S3_TESTS=true
|
||||
```
|
||||
|
||||
### Running Unit Tests
|
||||
|
||||
```bash
|
||||
# Run all backup service tests
|
||||
npm test -- __tests__/services/backupService.enhanced.test.js
|
||||
|
||||
# Run specific test suite
|
||||
npm test -- __tests__/services/backupService.enhanced.test.js -t "S3 Backup Functionality"
|
||||
|
||||
# Run with coverage
|
||||
npm test -- --coverage __tests__/services/backupService.enhanced.test.js
|
||||
```
|
||||
|
||||
### Running Integration Tests
|
||||
|
||||
```bash
|
||||
# Ensure MinIO is running first!
|
||||
|
||||
# Run S3 integration tests
|
||||
npm test -- __tests__/integration/backup-s3.test.js
|
||||
|
||||
# Run with verbose output
|
||||
npm test -- __tests__/integration/backup-s3.test.js --verbose
|
||||
|
||||
# Skip S3 tests if needed
|
||||
SKIP_S3_TESTS=true npm test -- __tests__/integration/backup-s3.test.js
|
||||
```
|
||||
|
||||
### Running Manual Integration Tests
|
||||
|
||||
```bash
|
||||
# Test with local MinIO (default)
|
||||
node scripts/test-backup-integration.js
|
||||
|
||||
# Test with AWS S3
|
||||
node scripts/test-backup-integration.js \
|
||||
--endpoint https://s3.amazonaws.com \
|
||||
--access-key YOUR_ACCESS_KEY \
|
||||
--secret-key YOUR_SECRET_KEY \
|
||||
--bucket your-test-bucket
|
||||
|
||||
# Test local backup
|
||||
node scripts/test-backup-integration.js --type local
|
||||
|
||||
# Test with cleanup after completion
|
||||
node scripts/test-backup-integration.js --cleanup
|
||||
|
||||
# Verbose output
|
||||
node scripts/test-backup-integration.js --verbose
|
||||
```
|
||||
|
||||
## Test Coverage
|
||||
|
||||
The test suite covers:
|
||||
|
||||
### Configuration
|
||||
- ✅ Database configuration retrieval
|
||||
- ✅ JSON parsing and error handling
|
||||
- ✅ Configuration validation
|
||||
- ✅ Required field validation
|
||||
|
||||
### S3 Functionality
|
||||
- ✅ S3 client initialization
|
||||
- ✅ Connection testing
|
||||
- ✅ File upload with progress tracking
|
||||
- ✅ Large file handling (multipart upload)
|
||||
- ✅ Metadata and custom headers
|
||||
- ✅ Error handling and retries
|
||||
|
||||
### Backup Process
|
||||
- ✅ Full backup execution
|
||||
- ✅ Incremental backup (changed files only)
|
||||
- ✅ File checksum calculation and comparison
|
||||
- ✅ Database backup inclusion
|
||||
- ✅ Archive inclusion toggle
|
||||
- ✅ File size limits
|
||||
|
||||
### Manifest Generation
|
||||
- ✅ Full manifest generation
|
||||
- ✅ Incremental manifest with parent reference
|
||||
- ✅ JSON and YAML format support
|
||||
- ✅ Manifest validation
|
||||
- ✅ S3 manifest storage and retrieval
|
||||
- ✅ Checksum verification
|
||||
|
||||
### Error Handling
|
||||
- ✅ S3 connection failures
|
||||
- ✅ File read errors
|
||||
- ✅ Individual file failure recovery
|
||||
- ✅ Retry logic with exponential backoff
|
||||
- ✅ Email notifications on failure
|
||||
- ✅ Concurrent backup prevention
|
||||
|
||||
### Backward Compatibility
|
||||
- ✅ Local directory backup
|
||||
- ✅ Rsync backup
|
||||
- ✅ Existing manifest format support
|
||||
|
||||
### Service Management
|
||||
- ✅ Cron job scheduling
|
||||
- ✅ Service start/stop
|
||||
- ✅ Manual backup triggering
|
||||
- ✅ Backup history and status
|
||||
|
||||
## Mock Setup
|
||||
|
||||
The unit tests use comprehensive mocking:
|
||||
|
||||
```javascript
|
||||
// Database mocking
|
||||
jest.mock('../../src/database/db');
|
||||
|
||||
// S3 client mocking
|
||||
jest.mock('../../src/services/storage/s3Storage');
|
||||
|
||||
// File system mocking
|
||||
const mockFs = require('mock-fs');
|
||||
|
||||
// Cron job mocking
|
||||
jest.mock('node-cron');
|
||||
```
|
||||
|
||||
## CI/CD Integration
|
||||
|
||||
To run tests in CI/CD pipeline:
|
||||
|
||||
```yaml
|
||||
# Example GitHub Actions
|
||||
- name: Run Unit Tests
|
||||
run: npm test -- __tests__/services/backupService.enhanced.test.js
|
||||
|
||||
- name: Start MinIO
|
||||
run: |
|
||||
docker run -d \
|
||||
-p 9000:9000 \
|
||||
--name minio-test \
|
||||
-e MINIO_ROOT_USER=minioadmin \
|
||||
-e MINIO_ROOT_PASSWORD=minioadmin \
|
||||
minio/minio server /data
|
||||
|
||||
- name: Run Integration Tests
|
||||
run: npm test -- __tests__/integration/backup-s3.test.js
|
||||
```
|
||||
|
||||
## Debugging Tests
|
||||
|
||||
```bash
|
||||
# Run tests in debug mode
|
||||
node --inspect-brk ./node_modules/.bin/jest __tests__/services/backupService.enhanced.test.js
|
||||
|
||||
# Run single test with console output
|
||||
npm test -- __tests__/services/backupService.enhanced.test.js -t "should perform S3 backup" --verbose
|
||||
```
|
||||
|
||||
## Performance Considerations
|
||||
|
||||
- Integration tests create real files and S3 objects
|
||||
- Each test run creates a unique S3 bucket to avoid conflicts
|
||||
- Cleanup is automatic but can be disabled for debugging
|
||||
- Large file tests (10MB+) are included but can be slow
|
||||
|
||||
## Adding New Tests
|
||||
|
||||
When adding new backup features:
|
||||
|
||||
1. Add unit tests to `backupService.enhanced.test.js`
|
||||
2. Add integration tests to `backup-s3.test.js` if S3-specific
|
||||
3. Update manual test script for comprehensive testing
|
||||
4. Ensure mocks are properly configured
|
||||
5. Document any new environment requirements
|
||||
@@ -0,0 +1,506 @@
|
||||
const { describe, it, expect, jest, beforeAll, afterAll, beforeEach, afterEach } = require('@jest/globals');
|
||||
const { S3Client, CreateBucketCommand, DeleteBucketCommand, ListObjectsV2Command, DeleteObjectsCommand } = require('@aws-sdk/client-s3');
|
||||
const path = require('path');
|
||||
const fs = require('fs').promises;
|
||||
const crypto = require('crypto');
|
||||
|
||||
// Load services
|
||||
const backupService = require('../../src/services/backupService');
|
||||
const S3StorageAdapter = require('../../src/services/storage/s3Storage');
|
||||
const { db, initialize: initDb } = require('../../src/database/db');
|
||||
const logger = require('../../src/utils/logger');
|
||||
|
||||
// Test configuration
|
||||
const TEST_CONFIG = {
|
||||
endpoint: process.env.TEST_S3_ENDPOINT || 'http://localhost:9000',
|
||||
accessKeyId: process.env.TEST_S3_ACCESS_KEY || 'minioadmin',
|
||||
secretAccessKey: process.env.TEST_S3_SECRET_KEY || 'minioadmin',
|
||||
bucket: 'test-backup-bucket-' + Date.now(),
|
||||
region: 'us-east-1'
|
||||
};
|
||||
|
||||
describe('S3 Backup Integration Tests', () => {
|
||||
let s3Client;
|
||||
let testStoragePath;
|
||||
let originalEnv;
|
||||
|
||||
beforeAll(async () => {
|
||||
// Skip if no S3 endpoint configured
|
||||
if (process.env.SKIP_S3_TESTS === 'true') {
|
||||
console.log('Skipping S3 integration tests (SKIP_S3_TESTS=true)');
|
||||
return;
|
||||
}
|
||||
|
||||
// Save original environment
|
||||
originalEnv = { ...process.env };
|
||||
|
||||
// Initialize S3 client for test setup
|
||||
s3Client = new S3Client({
|
||||
endpoint: TEST_CONFIG.endpoint,
|
||||
region: TEST_CONFIG.region,
|
||||
credentials: {
|
||||
accessKeyId: TEST_CONFIG.accessKeyId,
|
||||
secretAccessKey: TEST_CONFIG.secretAccessKey
|
||||
},
|
||||
forcePathStyle: true
|
||||
});
|
||||
|
||||
// Create test bucket
|
||||
try {
|
||||
await s3Client.send(new CreateBucketCommand({ Bucket: TEST_CONFIG.bucket }));
|
||||
console.log(`Created test bucket: ${TEST_CONFIG.bucket}`);
|
||||
} catch (error) {
|
||||
if (error.name !== 'BucketAlreadyOwnedByYou') {
|
||||
console.error('Failed to create test bucket:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
// Initialize database
|
||||
await initDb();
|
||||
await db.migrate.latest();
|
||||
|
||||
// Create test storage directory
|
||||
testStoragePath = path.join(__dirname, '../fixtures/test-storage');
|
||||
await fs.mkdir(testStoragePath, { recursive: true });
|
||||
process.env.STORAGE_PATH = testStoragePath;
|
||||
|
||||
// Set up test data
|
||||
await setupTestData();
|
||||
|
||||
// Mock logger to reduce noise
|
||||
logger.info = jest.fn();
|
||||
logger.debug = jest.fn();
|
||||
logger.warn = jest.fn();
|
||||
logger.error = jest.fn();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
try {
|
||||
// Clean up S3 bucket
|
||||
await cleanupS3Bucket();
|
||||
await s3Client.send(new DeleteBucketCommand({ Bucket: TEST_CONFIG.bucket }));
|
||||
console.log(`Deleted test bucket: ${TEST_CONFIG.bucket}`);
|
||||
} catch (error) {
|
||||
console.error('Failed to cleanup S3 bucket:', error);
|
||||
}
|
||||
|
||||
// Clean up test storage
|
||||
await fs.rm(testStoragePath, { recursive: true, force: true });
|
||||
|
||||
// Restore environment
|
||||
process.env = originalEnv;
|
||||
|
||||
// Close database
|
||||
await db.destroy();
|
||||
});
|
||||
|
||||
beforeEach(async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') {
|
||||
return;
|
||||
}
|
||||
|
||||
// Clean backup tables
|
||||
await db('backup_runs').del();
|
||||
await db('backup_file_states').del();
|
||||
await db('database_backup_runs').del();
|
||||
|
||||
// Configure S3 backup settings
|
||||
await configureS3Backup();
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Clean up S3 objects created during test
|
||||
await cleanupS3Bucket();
|
||||
});
|
||||
|
||||
describe('S3 Connection and Configuration', () => {
|
||||
it('should successfully connect to S3-compatible storage', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
const s3Adapter = new S3StorageAdapter({
|
||||
...TEST_CONFIG,
|
||||
bucket: TEST_CONFIG.bucket,
|
||||
forcePathStyle: true,
|
||||
sslEnabled: false
|
||||
});
|
||||
|
||||
const connected = await s3Adapter.testConnection();
|
||||
expect(connected).toBe(true);
|
||||
});
|
||||
|
||||
it('should validate S3 configuration before backup', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Remove required configuration
|
||||
await db('app_settings')
|
||||
.where('setting_key', 'backup_s3_secret_key')
|
||||
.del();
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
const lastRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
expect(lastRun.status).toBe('failed');
|
||||
expect(lastRun.error_message).toContain('S3 backup configuration incomplete');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Full S3 Backup Process', () => {
|
||||
it('should perform complete S3 backup with all file types', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Run backup
|
||||
await backupService.runBackup();
|
||||
|
||||
// Verify backup run completed
|
||||
const backupRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
expect(backupRun.status).toBe('completed');
|
||||
expect(backupRun.files_backed_up).toBeGreaterThan(0);
|
||||
expect(backupRun.total_size_bytes).toBeGreaterThan(0);
|
||||
|
||||
// Verify files in S3
|
||||
const s3Objects = await listS3Objects();
|
||||
expect(s3Objects.length).toBeGreaterThan(0);
|
||||
|
||||
// Check for expected file types
|
||||
const hasPhotos = s3Objects.some(obj => obj.Key.includes('events/active'));
|
||||
const hasThumbnails = s3Objects.some(obj => obj.Key.includes('thumbnails'));
|
||||
const hasManifest = s3Objects.some(obj => obj.Key.includes('backup-manifest'));
|
||||
const hasSummary = s3Objects.some(obj => obj.Key.includes('backup-summary.json'));
|
||||
|
||||
expect(hasPhotos).toBe(true);
|
||||
expect(hasThumbnails).toBe(true);
|
||||
expect(hasManifest).toBe(true);
|
||||
expect(hasSummary).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle large file uploads with multipart', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Create a large test file (15MB)
|
||||
const largeFilePath = path.join(testStoragePath, 'events/active/large-photo.jpg');
|
||||
const largeFileSize = 15 * 1024 * 1024; // 15MB
|
||||
const largeFileContent = Buffer.alloc(largeFileSize, 'x');
|
||||
await fs.writeFile(largeFilePath, largeFileContent);
|
||||
|
||||
// Run backup
|
||||
await backupService.runBackup();
|
||||
|
||||
// Verify large file was uploaded
|
||||
const s3Objects = await listS3Objects();
|
||||
const largeFileUploaded = s3Objects.some(obj =>
|
||||
obj.Key.includes('large-photo.jpg') && obj.Size === largeFileSize
|
||||
);
|
||||
|
||||
expect(largeFileUploaded).toBe(true);
|
||||
});
|
||||
|
||||
it('should include database backup when available', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Create a mock database backup
|
||||
const dbBackupPath = path.join(testStoragePath, 'backups/db-backup.sql');
|
||||
await fs.mkdir(path.dirname(dbBackupPath), { recursive: true });
|
||||
await fs.writeFile(dbBackupPath, 'CREATE TABLE test (id INT);');
|
||||
|
||||
// Record database backup
|
||||
await db('database_backup_runs').insert({
|
||||
started_at: new Date(),
|
||||
completed_at: new Date(),
|
||||
status: 'completed',
|
||||
backup_type: 'sqlite',
|
||||
file_path: dbBackupPath,
|
||||
file_size_bytes: 100,
|
||||
checksum: 'test123',
|
||||
statistics: JSON.stringify({ tables: {} }),
|
||||
table_checksums: JSON.stringify({})
|
||||
});
|
||||
|
||||
// Configure to include database
|
||||
await db('app_settings')
|
||||
.where('setting_key', 'backup_include_database')
|
||||
.update({ setting_value: 'true' });
|
||||
|
||||
// Run backup
|
||||
await backupService.runBackup();
|
||||
|
||||
// Verify database backup in S3
|
||||
const s3Objects = await listS3Objects();
|
||||
const hasDbBackup = s3Objects.some(obj => obj.Key.includes('database/db-backup.sql'));
|
||||
expect(hasDbBackup).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Incremental Backup', () => {
|
||||
it('should only upload changed files in incremental backup', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// First backup - full
|
||||
await backupService.runBackup();
|
||||
|
||||
const firstRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
const firstObjectCount = (await listS3Objects()).length;
|
||||
|
||||
// Wait a moment to ensure different timestamps
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
// Modify one file
|
||||
const modifiedFile = path.join(testStoragePath, 'events/active/event1/photo1.jpg');
|
||||
await fs.writeFile(modifiedFile, 'modified content');
|
||||
|
||||
// Second backup - incremental
|
||||
await backupService.runBackup();
|
||||
|
||||
const secondRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
expect(secondRun.id).not.toBe(firstRun.id);
|
||||
expect(secondRun.files_backed_up).toBe(1); // Only modified file
|
||||
|
||||
// Check manifest indicates incremental
|
||||
if (secondRun.manifest_path) {
|
||||
const manifest = await backupService.getBackupManifest(secondRun.id);
|
||||
expect(manifest.manifest.incremental).toBeDefined();
|
||||
expect(manifest.manifest.incremental.modified_files_count).toBe(1);
|
||||
}
|
||||
});
|
||||
|
||||
it('should track file states across backups', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
// Check file states are recorded
|
||||
const fileStates = await db('backup_file_states').select('*');
|
||||
expect(fileStates.length).toBeGreaterThan(0);
|
||||
|
||||
// Verify checksums are stored
|
||||
const hasChecksums = fileStates.every(state => state.checksum !== null);
|
||||
expect(hasChecksums).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('S3 Manifest Storage', () => {
|
||||
it('should upload manifest to S3 and retrieve it', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Configure YAML manifest format
|
||||
await db('app_settings')
|
||||
.where('setting_key', 'backup_manifest_format')
|
||||
.update({ setting_value: '"yaml"' });
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
const backupRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
expect(backupRun.manifest_path).toMatch(/^s3:\/\//);
|
||||
|
||||
// Retrieve manifest
|
||||
const { manifest, summary } = await backupService.getBackupManifest(backupRun.id);
|
||||
|
||||
expect(manifest).toBeDefined();
|
||||
expect(manifest.backup.id).toBeDefined();
|
||||
expect(summary).toContain('BACKUP MANIFEST SUMMARY');
|
||||
});
|
||||
|
||||
it('should validate manifest integrity', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
const backupRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
const validationResult = await backupService.validateBackupManifest(backupRun.manifest_path);
|
||||
|
||||
expect(validationResult.valid).toBe(true);
|
||||
expect(validationResult.manifest).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Error Recovery', () => {
|
||||
it('should handle S3 connection failures gracefully', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Configure with invalid endpoint
|
||||
await db('app_settings')
|
||||
.where('setting_key', 'backup_s3_endpoint')
|
||||
.update({ setting_value: '"http://invalid-endpoint:9999"' });
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
const backupRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
expect(backupRun.status).toBe('failed');
|
||||
expect(backupRun.error_message).toBeDefined();
|
||||
});
|
||||
|
||||
it('should continue backup despite individual file failures', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Create a file that will be deleted during backup
|
||||
const tempFile = path.join(testStoragePath, 'events/active/temp.jpg');
|
||||
await fs.writeFile(tempFile, 'temporary');
|
||||
|
||||
// Mock file deletion during backup
|
||||
const originalUpload = S3StorageAdapter.prototype.upload;
|
||||
let callCount = 0;
|
||||
S3StorageAdapter.prototype.upload = jest.fn(async function(localPath, s3Key, options) {
|
||||
callCount++;
|
||||
if (callCount === 2) {
|
||||
// Delete the temp file to cause an error
|
||||
await fs.unlink(tempFile).catch(() => {});
|
||||
}
|
||||
return originalUpload.call(this, localPath, s3Key, options);
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
const backupRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
// Should complete despite one file error
|
||||
expect(backupRun.status).toBe('completed');
|
||||
expect(backupRun.files_backed_up).toBeGreaterThan(0);
|
||||
|
||||
// Restore original method
|
||||
S3StorageAdapter.prototype.upload = originalUpload;
|
||||
});
|
||||
|
||||
it('should retry failed uploads with exponential backoff', async () => {
|
||||
if (process.env.SKIP_S3_TESTS === 'true') return;
|
||||
|
||||
// Mock S3 upload to fail twice then succeed
|
||||
const originalUpload = S3StorageAdapter.prototype.upload;
|
||||
let attemptCount = 0;
|
||||
S3StorageAdapter.prototype.upload = jest.fn(async function(localPath, s3Key, options) {
|
||||
attemptCount++;
|
||||
if (attemptCount <= 2) {
|
||||
const error = new Error('Network timeout');
|
||||
error.code = 'ETIMEDOUT';
|
||||
throw error;
|
||||
}
|
||||
return originalUpload.call(this, localPath, s3Key, options);
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
const backupRun = await db('backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.first();
|
||||
|
||||
// Should succeed after retries
|
||||
expect(backupRun.status).toBe('completed');
|
||||
expect(attemptCount).toBeGreaterThan(2);
|
||||
|
||||
// Restore original method
|
||||
S3StorageAdapter.prototype.upload = originalUpload;
|
||||
});
|
||||
});
|
||||
|
||||
// Helper functions
|
||||
|
||||
async function setupTestData() {
|
||||
// Create test directory structure
|
||||
const dirs = [
|
||||
'events/active/event1',
|
||||
'events/active/event2',
|
||||
'events/archived',
|
||||
'thumbnails',
|
||||
'uploads'
|
||||
];
|
||||
|
||||
for (const dir of dirs) {
|
||||
await fs.mkdir(path.join(testStoragePath, dir), { recursive: true });
|
||||
}
|
||||
|
||||
// Create test files
|
||||
const files = [
|
||||
{ path: 'events/active/event1/photo1.jpg', content: 'photo1 content' },
|
||||
{ path: 'events/active/event1/photo2.jpg', content: 'photo2 content' },
|
||||
{ path: 'events/active/event2/photo3.jpg', content: 'photo3 content' },
|
||||
{ path: 'events/archived/old-event.zip', content: 'archived content' },
|
||||
{ path: 'thumbnails/thumb1.jpg', content: 'thumbnail content' },
|
||||
{ path: 'uploads/logo.png', content: 'logo content' }
|
||||
];
|
||||
|
||||
for (const file of files) {
|
||||
await fs.writeFile(
|
||||
path.join(testStoragePath, file.path),
|
||||
file.content
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
async function configureS3Backup() {
|
||||
const settings = [
|
||||
{ setting_key: 'backup_enabled', setting_value: 'true' },
|
||||
{ setting_key: 'backup_destination_type', setting_value: '"s3"' },
|
||||
{ setting_key: 'backup_s3_bucket', setting_value: `"${TEST_CONFIG.bucket}"` },
|
||||
{ setting_key: 'backup_s3_region', setting_value: `"${TEST_CONFIG.region}"` },
|
||||
{ setting_key: 'backup_s3_endpoint', setting_value: `"${TEST_CONFIG.endpoint}"` },
|
||||
{ setting_key: 'backup_s3_access_key', setting_value: `"${TEST_CONFIG.accessKeyId}"` },
|
||||
{ setting_key: 'backup_s3_secret_key', setting_value: `"${TEST_CONFIG.secretAccessKey}"` },
|
||||
{ setting_key: 'backup_s3_force_path_style', setting_value: 'true' },
|
||||
{ setting_key: 'backup_s3_ssl_enabled', setting_value: 'false' },
|
||||
{ setting_key: 'backup_include_archived', setting_value: 'true' },
|
||||
{ setting_key: 'backup_incremental', setting_value: 'true' },
|
||||
{ setting_key: 'backup_max_file_size_mb', setting_value: '100' }
|
||||
];
|
||||
|
||||
for (const setting of settings) {
|
||||
await db('app_settings')
|
||||
.insert({
|
||||
setting_type: 'backup',
|
||||
...setting,
|
||||
created_at: new Date(),
|
||||
updated_at: new Date()
|
||||
})
|
||||
.onConflict(['setting_type', 'setting_key'])
|
||||
.merge();
|
||||
}
|
||||
}
|
||||
|
||||
async function listS3Objects() {
|
||||
const response = await s3Client.send(new ListObjectsV2Command({
|
||||
Bucket: TEST_CONFIG.bucket
|
||||
}));
|
||||
return response.Contents || [];
|
||||
}
|
||||
|
||||
async function cleanupS3Bucket() {
|
||||
try {
|
||||
const objects = await listS3Objects();
|
||||
if (objects.length > 0) {
|
||||
await s3Client.send(new DeleteObjectsCommand({
|
||||
Bucket: TEST_CONFIG.bucket,
|
||||
Delete: {
|
||||
Objects: objects.map(obj => ({ Key: obj.Key }))
|
||||
}
|
||||
}));
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Failed to cleanup S3 objects:', error);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,751 @@
|
||||
const { describe, it, expect, jest, beforeEach, afterEach } = require('@jest/globals');
|
||||
const mockFs = require('mock-fs');
|
||||
const path = require('path');
|
||||
const crypto = require('crypto');
|
||||
const { EventEmitter } = require('events');
|
||||
|
||||
// Mock dependencies before requiring the module
|
||||
jest.mock('../../src/database/db');
|
||||
jest.mock('../../src/utils/logger');
|
||||
jest.mock('../../src/services/emailProcessor');
|
||||
jest.mock('node-cron');
|
||||
jest.mock('../../src/services/backupManifest');
|
||||
jest.mock('../../src/services/storage/s3Storage');
|
||||
|
||||
const backupService = require('../../src/services/backupService');
|
||||
const { db } = require('../../src/database/db');
|
||||
const logger = require('../../src/utils/logger');
|
||||
const { queueEmail } = require('../../src/services/emailProcessor');
|
||||
const cron = require('node-cron');
|
||||
const backupManifest = require('../../src/services/backupManifest');
|
||||
const S3StorageAdapter = require('../../src/services/storage/s3Storage');
|
||||
|
||||
describe('Enhanced Backup Service Tests', () => {
|
||||
let mockDb;
|
||||
let mockS3Client;
|
||||
let mockCronJob;
|
||||
|
||||
beforeEach(() => {
|
||||
// Reset all mocks
|
||||
jest.clearAllMocks();
|
||||
|
||||
// Mock database
|
||||
mockDb = {
|
||||
select: jest.fn().mockReturnThis(),
|
||||
where: jest.fn().mockReturnThis(),
|
||||
orderBy: jest.fn().mockReturnThis(),
|
||||
limit: jest.fn().mockReturnThis(),
|
||||
first: jest.fn(),
|
||||
insert: jest.fn(),
|
||||
update: jest.fn(),
|
||||
delete: jest.fn()
|
||||
};
|
||||
db.mockReturnValue(mockDb);
|
||||
|
||||
// Mock cron job
|
||||
mockCronJob = {
|
||||
stop: jest.fn()
|
||||
};
|
||||
cron.schedule.mockReturnValue(mockCronJob);
|
||||
|
||||
// Mock S3 client
|
||||
mockS3Client = {
|
||||
testConnection: jest.fn().mockResolvedValue(true),
|
||||
upload: jest.fn().mockResolvedValue({ Location: 's3://bucket/key' }),
|
||||
uploadStream: jest.fn().mockResolvedValue({ Location: 's3://bucket/key' }),
|
||||
download: jest.fn().mockResolvedValue(),
|
||||
exists: jest.fn().mockResolvedValue(false),
|
||||
delete: jest.fn().mockResolvedValue(),
|
||||
list: jest.fn().mockResolvedValue({ Contents: [] })
|
||||
};
|
||||
S3StorageAdapter.mockImplementation(() => mockS3Client);
|
||||
|
||||
// Mock backup manifest
|
||||
backupManifest.generateManifest = jest.fn().mockResolvedValue({
|
||||
backup: { id: 'test-backup-123' },
|
||||
version: '2.0'
|
||||
});
|
||||
backupManifest.saveManifest = jest.fn().mockResolvedValue('/path/to/manifest.json');
|
||||
backupManifest.loadManifest = jest.fn().mockResolvedValue({});
|
||||
backupManifest.validateManifest = jest.fn();
|
||||
backupManifest.generateSummaryReport = jest.fn().mockReturnValue('Summary report');
|
||||
|
||||
// Mock logger
|
||||
logger.info = jest.fn();
|
||||
logger.error = jest.fn();
|
||||
logger.warn = jest.fn();
|
||||
logger.debug = jest.fn();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
mockFs.restore();
|
||||
});
|
||||
|
||||
describe('getBackupConfig', () => {
|
||||
it('should retrieve and parse backup configuration from database', async () => {
|
||||
const mockSettings = [
|
||||
{ setting_key: 'backup_enabled', setting_value: 'true' },
|
||||
{ setting_key: 'backup_destination_type', setting_value: '"s3"' },
|
||||
{ setting_key: 'backup_s3_bucket', setting_value: '"test-bucket"' },
|
||||
{ setting_key: 'backup_retention_days', setting_value: '30' }
|
||||
];
|
||||
|
||||
mockDb.select.mockResolvedValue(mockSettings);
|
||||
|
||||
const config = await backupService.getBackupConfig();
|
||||
|
||||
expect(config).toEqual({
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket',
|
||||
backup_retention_days: 30
|
||||
});
|
||||
|
||||
expect(db).toHaveBeenCalledWith('app_settings');
|
||||
expect(mockDb.where).toHaveBeenCalledWith('setting_type', 'backup');
|
||||
});
|
||||
|
||||
it('should handle JSON parse errors gracefully', async () => {
|
||||
const mockSettings = [
|
||||
{ setting_key: 'backup_enabled', setting_value: 'invalid-json' }
|
||||
];
|
||||
|
||||
mockDb.select.mockResolvedValue(mockSettings);
|
||||
|
||||
const config = await backupService.getBackupConfig();
|
||||
|
||||
expect(config).toEqual({
|
||||
backup_enabled: 'invalid-json'
|
||||
});
|
||||
});
|
||||
|
||||
it('should return null on database error', async () => {
|
||||
mockDb.select.mockRejectedValue(new Error('Database error'));
|
||||
|
||||
const config = await backupService.getBackupConfig();
|
||||
|
||||
expect(config).toBeNull();
|
||||
expect(logger.error).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('S3 Backup Functionality', () => {
|
||||
beforeEach(() => {
|
||||
// Mock file system
|
||||
mockFs({
|
||||
'/storage/events/active/event1': {
|
||||
'photo1.jpg': Buffer.from('photo1 content'),
|
||||
'photo2.jpg': Buffer.from('photo2 content')
|
||||
},
|
||||
'/storage/events/archived/event2.zip': Buffer.from('archived content'),
|
||||
'/storage/thumbnails': {
|
||||
'thumb1.jpg': Buffer.from('thumb1 content')
|
||||
},
|
||||
'/storage/uploads': {
|
||||
'logo.png': Buffer.from('logo content')
|
||||
}
|
||||
});
|
||||
|
||||
process.env.STORAGE_PATH = '/storage';
|
||||
});
|
||||
|
||||
it('should perform S3 backup with correct configuration', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket',
|
||||
backup_s3_region: 'us-east-1',
|
||||
backup_s3_endpoint: 'https://s3.amazonaws.com',
|
||||
backup_s3_access_key: 'test-key',
|
||||
backup_s3_secret_key: 'test-secret',
|
||||
backup_include_archived: true,
|
||||
backup_max_file_size_mb: 100
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.where.mockReturnThis();
|
||||
mockDb.first.mockResolvedValue(null);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
jest.spyOn(backupService, 'getDatabaseBackupInfo').mockResolvedValue({
|
||||
type: 'sqlite',
|
||||
backupFile: null,
|
||||
hasChanged: true
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
expect(S3StorageAdapter).toHaveBeenCalledWith({
|
||||
bucket: 'test-bucket',
|
||||
region: 'us-east-1',
|
||||
endpoint: 'https://s3.amazonaws.com',
|
||||
accessKeyId: 'test-key',
|
||||
secretAccessKey: 'test-secret',
|
||||
forcePathStyle: false,
|
||||
sslEnabled: true,
|
||||
maxRetries: 3,
|
||||
retryDelay: 1000
|
||||
});
|
||||
|
||||
expect(mockS3Client.testConnection).toHaveBeenCalled();
|
||||
expect(mockS3Client.upload).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should handle S3 upload failures gracefully', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket',
|
||||
backup_s3_access_key: 'test-key',
|
||||
backup_s3_secret_key: 'test-secret'
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
mockDb.first.mockResolvedValue(null);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
mockS3Client.testConnection.mockRejectedValue(new Error('Connection failed'));
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
expect(logger.error).toHaveBeenCalledWith('S3 backup failed:', expect.any(Error));
|
||||
expect(mockDb.update).toHaveBeenCalledWith(expect.objectContaining({
|
||||
status: 'failed',
|
||||
error_message: expect.stringContaining('Connection failed')
|
||||
}));
|
||||
});
|
||||
|
||||
it('should skip unchanged files in incremental backup', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket',
|
||||
backup_s3_access_key: 'test-key',
|
||||
backup_s3_secret_key: 'test-secret',
|
||||
backup_incremental: true
|
||||
};
|
||||
|
||||
// Mock existing file state
|
||||
mockDb.first.mockImplementation((query) => {
|
||||
if (query === undefined) {
|
||||
return Promise.resolve({
|
||||
file_path: 'events/active/event1/photo1.jpg',
|
||||
checksum: crypto.createHash('sha256').update('photo1 content').digest('hex')
|
||||
});
|
||||
}
|
||||
return Promise.resolve(null);
|
||||
});
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
// Should skip unchanged file
|
||||
const uploadCalls = mockS3Client.upload.mock.calls;
|
||||
const photo1Uploaded = uploadCalls.some(call =>
|
||||
call[1].includes('photo1.jpg')
|
||||
);
|
||||
expect(photo1Uploaded).toBe(false);
|
||||
});
|
||||
|
||||
it('should include database backup when configured', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket',
|
||||
backup_s3_access_key: 'test-key',
|
||||
backup_s3_secret_key: 'test-secret',
|
||||
backup_include_database: true
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
jest.spyOn(backupService, 'getDatabaseBackupInfo').mockResolvedValue({
|
||||
type: 'sqlite',
|
||||
backupFile: '/backup/db-backup.sql',
|
||||
size: 1024000,
|
||||
checksum: 'abc123',
|
||||
hasChanged: false
|
||||
});
|
||||
|
||||
// Mock database backup file
|
||||
mockFs({
|
||||
'/storage/events/active': {},
|
||||
'/backup/db-backup.sql': Buffer.from('database backup content')
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
// Verify database backup was uploaded
|
||||
const uploadCalls = mockS3Client.upload.mock.calls;
|
||||
const dbBackupUploaded = uploadCalls.some(call =>
|
||||
call[1].includes('database/db-backup.sql')
|
||||
);
|
||||
expect(dbBackupUploaded).toBe(true);
|
||||
});
|
||||
|
||||
it('should validate required S3 configuration', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket'
|
||||
// Missing access key and secret key
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
expect(logger.error).toHaveBeenCalledWith(
|
||||
'S3 backup failed:',
|
||||
expect.objectContaining({
|
||||
message: expect.stringContaining('S3 backup configuration incomplete')
|
||||
})
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Manifest Generation', () => {
|
||||
it('should generate and save manifest for successful backup', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 'local',
|
||||
backup_destination_path: '/backup',
|
||||
backup_manifest_format: 'json'
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
mockDb.first.mockResolvedValue(null);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
mockFs({
|
||||
'/storage/events/active/event1': {
|
||||
'photo1.jpg': Buffer.from('photo1 content')
|
||||
},
|
||||
'/backup': {}
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
expect(backupManifest.generateManifest).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
backupType: 'full',
|
||||
backupPath: '/backup',
|
||||
format: 'json'
|
||||
})
|
||||
);
|
||||
|
||||
expect(backupManifest.saveManifest).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should generate incremental manifest when parent exists', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 'local',
|
||||
backup_destination_path: '/backup'
|
||||
};
|
||||
|
||||
const lastBackup = {
|
||||
id: 1,
|
||||
manifest_path: '/backup/manifests/previous.json',
|
||||
manifest_id: 'previous-backup-123'
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([2]);
|
||||
mockDb.first.mockImplementation(() => Promise.resolve(lastBackup));
|
||||
mockDb.orderBy.mockReturnThis();
|
||||
mockDb.where.mockReturnThis();
|
||||
mockDb.whereNot = jest.fn().mockReturnThis();
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
mockFs({
|
||||
'/storage/events/active': {},
|
||||
'/backup': {}
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
expect(backupManifest.loadManifest).toHaveBeenCalledWith('/backup/manifests/previous.json');
|
||||
expect(backupManifest.generateIncrementalManifest).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should upload manifest to S3 for S3 backups', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket',
|
||||
backup_s3_access_key: 'test-key',
|
||||
backup_s3_secret_key: 'test-secret',
|
||||
backup_manifest_format: 'yaml'
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
mockDb.first.mockResolvedValue(null);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
const manifest = {
|
||||
backup: { id: 'backup-123' },
|
||||
version: '2.0'
|
||||
};
|
||||
backupManifest.generateManifest.mockResolvedValue(manifest);
|
||||
|
||||
mockFs({
|
||||
'/storage/events/active': {},
|
||||
'/storage/temp': {}
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
// Verify manifest was uploaded to S3
|
||||
const uploadCalls = mockS3Client.upload.mock.calls;
|
||||
const manifestUploaded = uploadCalls.some(call =>
|
||||
call[1].includes('manifests/backup-manifest-backup-123.yaml')
|
||||
);
|
||||
expect(manifestUploaded).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Backward Compatibility', () => {
|
||||
it('should support local backup destination', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 'local',
|
||||
backup_destination_path: '/backup/local'
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
mockDb.first.mockResolvedValue(null);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
mockFs({
|
||||
'/storage/events/active/event1': {
|
||||
'photo1.jpg': Buffer.from('photo1 content')
|
||||
},
|
||||
'/backup/local': {}
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
// Verify files were copied to local destination
|
||||
const fs = require('fs');
|
||||
const destPath = '/backup/local/events/active/event1/photo1.jpg';
|
||||
expect(fs.existsSync(destPath)).toBe(true);
|
||||
});
|
||||
|
||||
it('should support rsync backup destination', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 'rsync',
|
||||
backup_rsync_host: 'backup.example.com',
|
||||
backup_rsync_user: 'backup',
|
||||
backup_rsync_path: '/remote/backup'
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
mockDb.first.mockResolvedValue(null);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
// Mock exec for rsync
|
||||
const { exec } = require('child_process');
|
||||
const mockExec = jest.fn((cmd, callback) => {
|
||||
callback(null, { stdout: 'Number of files transferred: 1\nTotal file size: 1024 bytes' });
|
||||
});
|
||||
exec.mockImplementation(mockExec);
|
||||
|
||||
mockFs({
|
||||
'/storage/events/active': {}
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
expect(mockExec).toHaveBeenCalledWith(
|
||||
expect.stringContaining('rsync'),
|
||||
expect.any(Function)
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Error Handling and Recovery', () => {
|
||||
it('should handle file read errors gracefully', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket',
|
||||
backup_s3_access_key: 'test-key',
|
||||
backup_s3_secret_key: 'test-secret'
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
mockDb.first.mockResolvedValue(null);
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
// Mock file that throws error on read
|
||||
const fs = require('fs');
|
||||
const originalCreateReadStream = fs.createReadStream;
|
||||
fs.createReadStream = jest.fn((path) => {
|
||||
if (path.includes('error.jpg')) {
|
||||
const stream = new EventEmitter();
|
||||
process.nextTick(() => stream.emit('error', new Error('File read error')));
|
||||
return stream;
|
||||
}
|
||||
return originalCreateReadStream(path);
|
||||
});
|
||||
|
||||
mockFs({
|
||||
'/storage/events/active': {
|
||||
'error.jpg': Buffer.from('content'),
|
||||
'good.jpg': Buffer.from('content')
|
||||
}
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
// Should continue with other files despite error
|
||||
expect(logger.error).toHaveBeenCalledWith(
|
||||
expect.stringContaining('Failed to backup file'),
|
||||
expect.any(Error)
|
||||
);
|
||||
|
||||
fs.createReadStream = originalCreateReadStream;
|
||||
});
|
||||
|
||||
it('should send failure email on backup error', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 's3',
|
||||
backup_s3_bucket: 'test-bucket',
|
||||
backup_email_on_failure: true
|
||||
};
|
||||
|
||||
const admins = [
|
||||
{ email: 'admin1@example.com', is_active: true },
|
||||
{ email: 'admin2@example.com', is_active: true }
|
||||
];
|
||||
|
||||
mockDb.select.mockResolvedValue([]);
|
||||
mockDb.insert.mockResolvedValue([1]);
|
||||
mockDb.where.mockReturnThis();
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig')
|
||||
.mockResolvedValueOnce(config)
|
||||
.mockResolvedValueOnce(config);
|
||||
|
||||
// Force an error
|
||||
jest.spyOn(backupService, 'getFilesToBackup').mockRejectedValue(new Error('Storage error'));
|
||||
|
||||
// Mock admin users query
|
||||
db.mockImplementation((table) => {
|
||||
if (table === 'admin_users') {
|
||||
return {
|
||||
where: jest.fn().mockResolvedValue(admins)
|
||||
};
|
||||
}
|
||||
return mockDb;
|
||||
});
|
||||
|
||||
await backupService.runBackup();
|
||||
|
||||
expect(queueEmail).toHaveBeenCalledTimes(2);
|
||||
expect(queueEmail).toHaveBeenCalledWith(
|
||||
null,
|
||||
'admin1@example.com',
|
||||
'backup_failed',
|
||||
expect.objectContaining({
|
||||
error_message: 'Storage error'
|
||||
})
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle concurrent backup attempts', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_destination_type: 'local',
|
||||
backup_destination_path: '/backup'
|
||||
};
|
||||
|
||||
jest.spyOn(backupService, 'getBackupConfig').mockResolvedValue(config);
|
||||
|
||||
mockFs({
|
||||
'/storage/events/active': {},
|
||||
'/backup': {}
|
||||
});
|
||||
|
||||
// Start two backups concurrently
|
||||
const backup1 = backupService.runBackup();
|
||||
const backup2 = backupService.runBackup();
|
||||
|
||||
await Promise.all([backup1, backup2]);
|
||||
|
||||
// Second backup should be skipped
|
||||
expect(logger.warn).toHaveBeenCalledWith('Backup already running, skipping');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Service Lifecycle', () => {
|
||||
it('should start backup service with cron schedule', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_schedule: '0 3 * * *' // 3 AM daily
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue(
|
||||
Object.entries(config).map(([key, value]) => ({
|
||||
setting_key: key,
|
||||
setting_value: value.toString()
|
||||
}))
|
||||
);
|
||||
|
||||
await backupService.startBackupService();
|
||||
|
||||
expect(cron.schedule).toHaveBeenCalledWith('0 3 * * *', expect.any(Function));
|
||||
expect(logger.info).toHaveBeenCalledWith('Backup service started with schedule: 0 3 * * *');
|
||||
});
|
||||
|
||||
it('should stop existing job when restarting service', async () => {
|
||||
const config = {
|
||||
backup_enabled: true,
|
||||
backup_schedule: '0 2 * * *'
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue(
|
||||
Object.entries(config).map(([key, value]) => ({
|
||||
setting_key: key,
|
||||
setting_value: value.toString()
|
||||
}))
|
||||
);
|
||||
|
||||
// Start service twice
|
||||
await backupService.startBackupService();
|
||||
await backupService.startBackupService();
|
||||
|
||||
expect(mockCronJob.stop).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should not start service when backup is disabled', async () => {
|
||||
const config = {
|
||||
backup_enabled: false
|
||||
};
|
||||
|
||||
mockDb.select.mockResolvedValue([
|
||||
{ setting_key: 'backup_enabled', setting_value: 'false' }
|
||||
]);
|
||||
|
||||
await backupService.startBackupService();
|
||||
|
||||
expect(cron.schedule).not.toHaveBeenCalled();
|
||||
expect(logger.info).toHaveBeenCalledWith('Backup service is disabled');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Backup Status and History', () => {
|
||||
it('should return backup status with recent runs', async () => {
|
||||
const recentRuns = [
|
||||
{
|
||||
id: 1,
|
||||
started_at: new Date(),
|
||||
completed_at: new Date(),
|
||||
status: 'completed',
|
||||
files_backed_up: 100,
|
||||
total_size_bytes: 1024000,
|
||||
manifest_path: '/backup/manifest.json'
|
||||
}
|
||||
];
|
||||
|
||||
mockDb.limit.mockResolvedValue(recentRuns);
|
||||
|
||||
backupManifest.validateManifest.mockImplementation(() => true);
|
||||
|
||||
const status = await backupService.getBackupStatus();
|
||||
|
||||
expect(status).toEqual({
|
||||
isRunning: false,
|
||||
isHealthy: true,
|
||||
lastRun: expect.objectContaining({
|
||||
...recentRuns[0],
|
||||
manifestValid: true
|
||||
}),
|
||||
recentRuns: recentRuns,
|
||||
nextScheduledRun: expect.any(String)
|
||||
});
|
||||
});
|
||||
|
||||
it('should clean up old backup runs', async () => {
|
||||
mockDb.delete.mockResolvedValue(5);
|
||||
|
||||
await backupService.cleanupOldBackupRuns(30);
|
||||
|
||||
expect(mockDb.where).toHaveBeenCalledWith('started_at', '<', expect.any(Date));
|
||||
expect(mockDb.delete).toHaveBeenCalled();
|
||||
expect(logger.info).toHaveBeenCalledWith('Cleaned up 5 old backup runs');
|
||||
});
|
||||
});
|
||||
|
||||
describe('getBackupManifest', () => {
|
||||
it('should retrieve manifest from local filesystem', async () => {
|
||||
const backupRun = {
|
||||
id: 1,
|
||||
manifest_path: '/backup/manifests/backup-123.json'
|
||||
};
|
||||
|
||||
mockDb.first.mockResolvedValue(backupRun);
|
||||
|
||||
const manifest = { backup: { id: 'backup-123' } };
|
||||
backupManifest.loadManifest.mockResolvedValue(manifest);
|
||||
backupManifest.generateSummaryReport.mockReturnValue('Summary');
|
||||
|
||||
const result = await backupService.getBackupManifest(1);
|
||||
|
||||
expect(result).toEqual({
|
||||
manifest: manifest,
|
||||
summary: 'Summary'
|
||||
});
|
||||
});
|
||||
|
||||
it('should retrieve manifest from S3', async () => {
|
||||
const backupRun = {
|
||||
id: 1,
|
||||
manifest_path: 's3://test-bucket/backups/manifests/backup-123.json'
|
||||
};
|
||||
|
||||
mockDb.first.mockResolvedValue(backupRun);
|
||||
mockDb.select.mockResolvedValue([
|
||||
{ setting_key: 'backup_s3_access_key', setting_value: '"test-key"' },
|
||||
{ setting_key: 'backup_s3_secret_key', setting_value: '"test-secret"' }
|
||||
]);
|
||||
|
||||
const manifest = { backup: { id: 'backup-123' } };
|
||||
backupManifest.loadManifest.mockResolvedValue(manifest);
|
||||
|
||||
await backupService.getBackupManifest(1);
|
||||
|
||||
expect(S3StorageAdapter).toHaveBeenCalled();
|
||||
expect(mockS3Client.download).toHaveBeenCalledWith(
|
||||
'backups/manifests/backup-123.json',
|
||||
expect.any(String)
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user