managarten/apps-archived/maerchenzauber/apps/backend/test/supabase-migration-test.ts

import { Test } from '@nestjs/testing';
import { AppModule } from '../src/app.module';
import { SupabaseJsonbService } from '../src/core/services/supabase-jsonb.service';
import { randomUUID } from 'crypto';
import { CustomFirestoreService } from '../src/core/services/firestore.service';
import { SettingsService } from '../src/core/services/settings.service';
import { SupabaseProvider } from '../src/supabase/supabase.provider';
import * as admin from 'firebase-admin';

// Initialize Firebase with mock credentials for testing
function initializeFirebase() {
	try {
		// Check if Firebase is already initialized
		admin.app();
		console.log('Firebase already initialized');
	} catch (error) {
		// Initialize Firebase with a minimal app
		admin.initializeApp({
			projectId: 'test-project',
		});
		console.log('Firebase initialized with mock app');
	}
}

// Create mock for Firebase Firestore
class MockFirestore {
	collection() {
		return this;
	}
	doc() {
		return this;
	}
	get() {
		return Promise.resolve({
			exists: true,
			data: () => ({
				replicateModel: 'test-model',
				authorPrompts: {},
				illustratorPrompts: {},
			}),
		});
	}
	set() {
		return Promise.resolve();
	}
	update() {
		return Promise.resolve();
	}
	delete() {
		return Promise.resolve();
	}
}

async function runTests() {
	// Initialize Firebase before creating the test module
	initializeFirebase();

	// Create a mock database to store data between operations
	const mockDatabase = {
		characters: new Map(),
		stories: new Map(),
	};

	// Mock Supabase client
	const mockSupabaseClient = {
		from: (table: string) => ({
			select: (columns = '*') => ({
				eq: (column: string, value: any) => ({
					single: () => {
						if (table === 'characters' && mockDatabase.characters.has(value)) {
							return Promise.resolve({
								data: mockDatabase.characters.get(value),
								error: null,
							});
						} else if (table === 'stories' && mockDatabase.stories.has(value)) {
							return Promise.resolve({
								data: mockDatabase.stories.get(value),
								error: null,
							});
						}
						return Promise.resolve({ data: null, error: null });
					},
					maybeSingle: () => Promise.resolve({ data: null, error: null }),
					order: () => Promise.resolve({ data: [], error: null }),
					limit: () => Promise.resolve({ data: [], error: null }),
				}),
				order: () => ({
					limit: () => Promise.resolve({ data: [], error: null }),
				}),
				limit: () => Promise.resolve({ data: [], error: null }),
			}),
			insert: (items: any[]) => ({
				select: () => {
					if (table === 'characters') {
						const item = { ...items[0] };
						mockDatabase.characters.set(item.id, item);
						return Promise.resolve({ data: [item], error: null });
					} else if (table === 'stories') {
						const item = { ...items[0] };
						mockDatabase.stories.set(item.id, item);
						return Promise.resolve({ data: [item], error: null });
					}
					return Promise.resolve({ data: items, error: null });
				},
			}),
			update: (data: any) => ({
				eq: (column: string, value: string) => {
					if (table === 'characters' && mockDatabase.characters.has(value)) {
						const item = mockDatabase.characters.get(value);
						const updatedItem = { ...item, ...data };
						mockDatabase.characters.set(value, updatedItem);
						return Promise.resolve({ data: [updatedItem], error: null });
					} else if (table === 'stories' && mockDatabase.stories.has(value)) {
						const item = mockDatabase.stories.get(value);
						const updatedItem = { ...item, ...data };
						mockDatabase.stories.set(value, updatedItem);
						return Promise.resolve({ data: [updatedItem], error: null });
					}
					return Promise.resolve({ data: [], error: null });
				},
				match: () => Promise.resolve({ data: {}, error: null }),
			}),
			delete: () => ({
				eq: (column: string, value: string) => {
					if (table === 'characters') {
						mockDatabase.characters.delete(value);
					} else if (table === 'stories') {
						mockDatabase.stories.delete(value);
					}
					return Promise.resolve({ data: {}, error: null });
				},
				match: () => Promise.resolve({ data: {}, error: null }),
			}),
			upsert: () => Promise.resolve({ data: {}, error: null }),
		}),
		storage: {
			from: () => ({
				upload: () => Promise.resolve({ data: {}, error: null }),
				getPublicUrl: () => ({
					data: { publicUrl: 'https://example.com/test.jpg' },
				}),
			}),
		},
		auth: {
			setSession: () => {},
		},
	};

	// Create a test NestJS application with mocked services
	const moduleRef = await Test.createTestingModule({
		imports: [AppModule],
	})
		.overrideProvider(CustomFirestoreService)
		.useValue({
			firestore: new MockFirestore(),
			getCharacterData: () => Promise.resolve({ data: {}, error: null }),
			getStoryData: () => Promise.resolve({ data: {}, error: null }),
			saveStory: () => Promise.resolve({ data: {}, error: null }),
			saveCharacter: () => Promise.resolve({ data: {}, error: null }),
		})
		.overrideProvider(SettingsService)
		.useValue({
			prompts: { author: {}, illustrator: {} },
			getAuthorPrompt: () => 'Test author prompt',
			getIllustratorPrompt: () => 'Test illustrator prompt',
			getReplicateModel: () => 'test-model',
			getCreators: () => [],
			getCreatorById: () => null,
			initialize: () => Promise.resolve(),
		})
		.overrideProvider(SupabaseProvider)
		.useValue({
			getClient: () => mockSupabaseClient,
		})
		.compile();

	const app = moduleRef.createNestApplication();
	await app.init();

	// Get the SupabaseJsonbService instance
	const supabaseService = app.get<SupabaseJsonbService>(SupabaseJsonbService);

	// Test user ID - use a real user ID or create a special test user
	const testUserId = 'test-user-' + randomUUID().substring(0, 8);

	try {
		console.log('=== SUPABASE MIGRATION TEST ===');
		console.log(`Using test user ID: ${testUserId}`);

		// Test 1: Create a character
		console.log('\n--- Test 1: Create a character ---');
		const characterId = randomUUID();

		const characterData = {
			id: characterId,
			name: 'Test Character',
			images_data: [
				{
					description: 'Test image description',
					image_url: 'https://example.com/test.jpg',
				},
			],
			original_description: 'A test character',
			character_description_prompt: 'A test character for Supabase migration',
			image_url: 'https://example.com/test.jpg',
			created_at: new Date().toISOString(),
			is_animal: false,
		};

		const character = await supabaseService.createCharacter(testUserId, characterData);
		console.log('Created character:', character ? 'Success' : 'Failed');

		// Test 2: Retrieve the character
		console.log('\n--- Test 2: Retrieve the character ---');
		const retrievedCharacter = await supabaseService.getCharacterById(characterId);
		console.log('Retrieved character:', retrievedCharacter ? 'Success' : 'Failed');
		console.log(
			'Character data matches:',
			retrievedCharacter &&
				retrievedCharacter.name === characterData.name &&
				retrievedCharacter.original_description === characterData.original_description
				? 'Yes'
				: 'No'
		);

		// Test 3: Create a story
		console.log('\n--- Test 3: Create a story ---');
		const storyId = randomUUID();

		const storyData = {
			id: storyId,
			title: 'Test Story',
			description: 'A test story for Supabase migration',
			pages_data: [
				{
					page_number: 1,
					story_text: 'Once upon a time...',
					illustration_description: 'A beautiful landscape',
					image_url: 'https://example.com/illustration1.jpg',
				},
				{
					page_number: 2,
					story_text: 'There was a brave character...',
					illustration_description: 'A character standing tall',
					image_url: 'https://example.com/illustration2.jpg',
				},
			],
			characters_data: [
				{
					character_description: 'A brave character',
					pages: [1, 2],
				},
			],
			combined_story: 'Once upon a time... There was a brave character...',
			created_at: new Date().toISOString(),
			user_id: testUserId,
			character_ids: [characterId],
		};

		const story = await supabaseService.createStory(testUserId, storyData);
		console.log('Created story:', story ? 'Success' : 'Failed');

		// Test 4: Retrieve the story
		console.log('\n--- Test 4: Retrieve the story ---');
		const retrievedStory = await supabaseService.getStoryById(storyId);
		console.log('Retrieved story:', retrievedStory ? 'Success' : 'Failed');
		console.log(
			'Story data matches:',
			retrievedStory &&
				retrievedStory.title === storyData.title &&
				retrievedStory.pages_data.length === storyData.pages_data.length
				? 'Yes'
				: 'No'
		);

		console.log('\n=== TEST SUMMARY ===');
		console.log('All tests completed. Check above logs for details.');
	} catch (error) {
		console.error('Test failed with error:', error);
	} finally {
		// Clean up
		await app.close();
	}
}

// Run the tests
runTests()
	.then(() => {
		console.log('Tests completed');
		process.exit(0);
	})
	.catch((error) => {
		console.error('Test script failed:', error);
		process.exit(1);
	});