application-form-7/tests/test_storage.py

"""
Tests for data storage (YAML files and file system operations).
"""
import pytest
import os
import yaml
from pathlib import Path
from app.models import (
    save_application_data,
    load_application_data,
    get_application_path,
    get_data_file_path,
    get_attachments_path
)


class TestYAMLStorage:
    """Tests for YAML data storage."""

    def test_save_application_data(self, app, sample_application_data):
        """Test saving application data to YAML file."""
        with app.app_context():
            session_id = sample_application_data['session_id']
            save_application_data(session_id, sample_application_data)

            # Verify file was created
            data_file = get_data_file_path(session_id)
            assert os.path.exists(data_file)

            # Verify content
            with open(data_file, 'r', encoding='utf-8') as f:
                loaded_data = yaml.safe_load(f)

            assert loaded_data['session_id'] == session_id
            assert loaded_data['email'] == sample_application_data['email']
            assert loaded_data['job_name'] == sample_application_data['job_name']

    def test_load_application_data(self, app, sample_application_data):
        """Test loading application data from YAML file."""
        with app.app_context():
            session_id = sample_application_data['session_id']

            # Save data first
            save_application_data(session_id, sample_application_data)

            # Load and verify
            loaded_data = load_application_data(session_id)
            assert loaded_data is not None
            assert loaded_data['session_id'] == session_id
            assert loaded_data['email'] == sample_application_data['email']
            assert loaded_data['personal_info']['name'] == 'Müller'

    def test_load_nonexistent_application(self, app):
        """Test loading data for non-existent application."""
        with app.app_context():
            loaded_data = load_application_data('nonexistent-session')
            assert loaded_data is None

    def test_unicode_characters_in_yaml(self, app):
        """Test that German umlauts and special characters are preserved."""
        with app.app_context():
            session_id = 'test-unicode-123'
            data = {
                'session_id': session_id,
                'email': 'test@example.com',
                'job_name': 'Test Job',
                'current_page': 2,
                'personal_info': {
                    'name': 'Müller',
                    'firstname': 'Jürgen',
                    'city': 'München',
                    'notes': 'Grüße aus Zürich'
                }
            }

            save_application_data(session_id, data)
            loaded_data = load_application_data(session_id)

            assert loaded_data['personal_info']['name'] == 'Müller'
            assert loaded_data['personal_info']['firstname'] == 'Jürgen'
            assert loaded_data['personal_info']['city'] == 'München'
            assert loaded_data['personal_info']['notes'] == 'Grüße aus Zürich'

    def test_update_existing_application(self, app, sample_application_data):
        """Test updating existing application data."""
        with app.app_context():
            session_id = sample_application_data['session_id']

            # Save initial data
            save_application_data(session_id, sample_application_data)

            # Update data
            sample_application_data['current_page'] = 3
            sample_application_data['motivation_answers'] = {
                'current_job': 'Developer',
                'motivation': 'Great company'
            }
            save_application_data(session_id, sample_application_data)

            # Verify update
            loaded_data = load_application_data(session_id)
            assert loaded_data['current_page'] == 3
            assert 'motivation_answers' in loaded_data
            assert loaded_data['motivation_answers']['current_job'] == 'Developer'


class TestFolderStructure:
    """Tests for application folder structure."""

    def test_application_folder_created(self, app, sample_application_data):
        """Test that application folder is created when saving data."""
        with app.app_context():
            session_id = sample_application_data['session_id']
            save_application_data(session_id, sample_application_data)

            app_path = get_application_path(session_id)
            assert os.path.exists(app_path)
            assert os.path.isdir(app_path)

    def test_data_yaml_created(self, app, sample_application_data):
        """Test that data.yaml file is created."""
        with app.app_context():
            session_id = sample_application_data['session_id']
            save_application_data(session_id, sample_application_data)

            data_file = get_data_file_path(session_id)
            assert os.path.exists(data_file)
            assert os.path.isfile(data_file)
            assert data_file.endswith('data.yaml')

    def test_attachments_folder_path(self, app):
        """Test that attachments folder path is correct."""
        with app.app_context():
            session_id = 'test-attachments-123'
            attachments_path = get_attachments_path(session_id)

            assert 'attachments' in attachments_path
            assert session_id in attachments_path


class TestDataPersistence:
    """Tests for data persistence across workflow."""

    def test_data_persists_across_pages(self, app, client):
        """Test that data persists as user progresses through pages."""
        # Submit email
        response = client.post('/apply/submit-email', data={
            'email': 'persist@example.com',
            'job_name': 'Persistence Test'
        }, follow_redirects=True)

        # Extract session ID from response
        # For testing, we'll create a known session
        from app.models import save_application_data
        session_id = 'test-persist-123'
        save_application_data(session_id, {
            'session_id': session_id,
            'email': 'persist@example.com',
            'job_name': 'Persistence Test',
            'current_page': 2,
            'personal_info': {},
            'motivation_answers': {},
            'uploaded_files': []
        })

        # Submit personal info
        client.post(f'/apply/{session_id}/submit-personal', data={
            'name': 'Test',
            'firstname': 'User',
            'address': 'Street 1',
            'zip_code': '12345',
            'city': 'City',
            'phone': '+41 79 123 45 67',
            'birth_year': '1990'
        })

        # Load and verify personal info was saved
        loaded_data = load_application_data(session_id)
        assert loaded_data is not None
        assert loaded_data['personal_info']['name'] == 'Test'
        assert loaded_data['personal_info']['firstname'] == 'User'
        assert loaded_data['current_page'] == 3  # Should be updated

        # Submit motivation
        client.post(f'/apply/{session_id}/submit-motivation', data={
            'current_job': 'Developer',
            'motivation': 'Love coding',
            'qualifications': 'Python expert',
            'salary': '100000'
        })

        # Load and verify motivation was saved
        loaded_data = load_application_data(session_id)
        assert loaded_data['motivation_answers']['current_job'] == 'Developer'
        assert loaded_data['motivation_answers']['motivation'] == 'Love coding'
        assert loaded_data['current_page'] == 4

    def test_empty_optional_fields_preserved(self, app):
        """Test that empty optional fields are preserved correctly."""
        with app.app_context():
            session_id = 'test-empty-fields'
            data = {
                'session_id': session_id,
                'email': 'test@example.com',
                'job_name': 'Test',
                'current_page': 3,
                'personal_info': {
                    'civil_status': ''  # Optional, empty
                },
                'motivation_answers': {
                    'current_job': '',  # Optional, empty
                    'motivation': 'Some text',
                    'qualifications': '',
                    'salary': ''
                }
            }

            save_application_data(session_id, data)
            loaded_data = load_application_data(session_id)

            assert loaded_data['personal_info']['civil_status'] == ''
            assert loaded_data['motivation_answers']['current_job'] == ''
            assert loaded_data['motivation_answers']['motivation'] == 'Some text'