half-orm-dev 0.17.3a5__py3-none-any.whl → 0.17.3a7__py3-none-any.whl

half_orm_dev/release_manager.py

@@ -744,27 +744,64 @@ class ReleaseManager:
         for patch_id in stage_patches:
             self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
 
-    def _generate_data_sql_file(self, patch_list: List[str], output_filename: str) -> Optional[Path]:
+    def _collect_all_version_patches(self, version: str) -> List[str]:
         """
-        Generate data-X.Y.Z.sql file from patches with @HOP:data annotation.
+        Collect all patches for a version including hotfixes.
+
+        Returns patches from:
+        1. Base release (X.Y.Z.txt)
+        2. All hotfixes in order (X.Y.Z-hotfix1.txt, X.Y.Z-hotfix2.txt, ...)
+
+        Args:
+            version: Base version string (e.g., "1.2.0")
+
+        Returns:
+            List of all patch IDs in application order
+
+        Examples:
+            # With 1.2.0.txt containing [a, b] and 1.2.0-hotfix1.txt containing [c]
+            patches = mgr._collect_all_version_patches("1.2.0")
+            # Returns: ["a", "b", "c"]
+        """
+        all_patches = []
+
+        # 1. Base release patches
+        base_file = f"{version}.txt"
+        all_patches.extend(self.read_release_patches(base_file))
+
+        # 2. Hotfix patches in order
+        hotfix_files = sorted(self._releases_dir.glob(f"{version}-hotfix*.txt"))
+        for hotfix_file in hotfix_files:
+            all_patches.extend(self.read_release_patches(hotfix_file.name))
+
+        return all_patches
+
+    def _generate_data_sql_file(self, patch_list: List[str], version: str) -> Optional[Path]:
+        """
+        Generate model/data-X.Y.Z.sql file from patches with @HOP:data annotation.
 
         Collects all SQL files marked with `-- @HOP:data` from the patch list
         and concatenates them into a single data SQL file for from-scratch
-        installations.
+        installations (clone, restore_database_from_schema).
+
+        This file is only generated for production releases. RC and hotfix
+        versions don't need this file because:
+        - In production upgrades, data is inserted by patch application
+        - This file is only for from-scratch installations
 
         Args:
             patch_list: List of patch IDs to process
-            output_filename: Name of the output file (e.g., "data-0.17.0-rc1.sql")
+            version: Version string (e.g., "0.17.0")
 
         Returns:
-            Path to generated file, or None if no data files found
+            Path to generated file (model/data-X.Y.Z.sql), or None if no data files found
 
         Examples:
             self._generate_data_sql_file(
                 ["456-auth", "457-roles"],
-                "data-0.17.0-rc1.sql"
+                "0.17.0"
             )
-            # Generates releases/data-0.17.0-rc1.sql with data from both patches
+            # Generates model/data-0.17.0.sql with data from both patches
         """
         if not patch_list:
             return None
@@ -777,16 +814,17 @@ class ReleaseManager:
                 # No data files found - skip generation
                 return None
 
-            # Generate output file
-            output_path = self._releases_dir / output_filename
+            # Generate output file in model/ directory
+            output_filename = f"data-{version}.sql"
+            output_path = Path(self._repo.model_dir) / output_filename
 
             with output_path.open('w', encoding='utf-8') as out_file:
                 # Write header
-                out_file.write(f"-- Data file for {output_filename.replace('.sql', '')}\n")
+                out_file.write(f"-- Data file for version {version}\n")
                 out_file.write(f"-- Generated from patches: {', '.join(patch_list)}\n")
                 out_file.write(f"-- This file contains reference data (DML) for from-scratch installations\n")
                 out_file.write(f"--\n")
-                out_file.write(f"-- Usage: psql -f {output_filename}\n")
+                out_file.write(f"-- Usage: Automatically loaded by restore_database_from_schema()\n")
                 out_file.write(f"--\n\n")
 
                 # Concatenate all data files
@@ -811,26 +849,30 @@ class ReleaseManager:
 
         except Exception as e:
             raise ReleaseManagerError(
-                f"Failed to generate data SQL file {output_filename}: {e}"
+                f"Failed to generate data SQL file data-{version}.sql: {e}"
             )
 
     def get_all_release_context_patches(self) -> List[str]:
         """
-        Récupère TOUS les patches du contexte de la prochaine release.
+        Get all validated patches for the next release context.
+
+        Sequential application of incremental RCs + staged patches from TOML.
+        - rc1: initial patches (e.g., 123, 456, 789)
+        - rc2: new patches (e.g., 999)
+        - rc3: new patches (e.g., 888, 777)
+        - TOML: only "staged" patches (validated via patch merge)
 
-        IMPORTANT: Application séquentielle des RC incrémentaux + TOML patches.
-        - rc1: patches initiaux (ex: 123, 456, 789)
-        - rc2: patches nouveaux (ex: 999)
-        - rc3: patches nouveaux (ex: 888, 777)
-        - TOML: TOUS les patches (candidates + staged) dans l'ordre
+        "candidate" patches are NOT included because they have not passed
+        the validation process (tests) that occurs during patch merge.
+        Only "staged" patches are guaranteed to have passed tests.
 
-        Résultat: [123, 456, 789, 999, 888, 777, ...]
+        The current patch is applied separately by apply_patch_complete_workflow.
 
-        Pas de déduplication car chaque RC est incrémental.
+        Note: A future "release apply" command could allow applying all patches
+        (candidates + staged) in a temporary branch for integration testing.
 
         Returns:
-            Liste ordonnée des patch IDs (séquence complète)
-            Inclut RC files + TOUS les patches du TOML (candidates + staged)
+            Ordered list of validated patch IDs (RC + staged)
 
         Examples:
             # Production: 1.3.5
@@ -839,14 +881,15 @@ class ReleaseManager:
             # 1.3.6-patches.toml: {"234": "candidate", "567": "staged"}
 
             patches = mgr.get_all_release_context_patches()
-            # → ["123", "456", "789", "999", "234", "567"]
+            # → ["123", "456", "789", "999", "567"]
+            # Note: "234" (candidate) is not included - not yet validated
 
-            # Pour apply-patch sur patch 888:
+            # For apply-patch on patch 234:
             # 1. Restore DB (1.3.5)
             # 2. Apply 123, 456, 789 (rc1)
             # 3. Apply 999 (rc2)
-            # 4. Apply 234, 567 (from TOML, all patches)
-            # 5. Apply 888 (patch courant)
+            # 4. Apply 567 (staged from TOML)
+            # 5. Apply 234 (current patch, applied separately)
         """
         next_version = self.get_next_release_version()
 
@@ -855,20 +898,21 @@ class ReleaseManager:
 
         all_patches = []
 
-        # 1. Appliquer tous les RC dans l'ordre (incrémentaux)
+        # 1. Apply all RCs in order (incremental)
         rc_files = self._get_label_files(next_version, 'rc')
         for rc_file in rc_files:
             patches = self.read_release_patches(rc_file)
-            # Chaque RC est incrémental, pas besoin de déduplication
+            # Each RC is incremental, no deduplication needed
             all_patches.extend(patches)
 
-        # 2. Appliquer TOUS les patches du TOML (candidates + staged)
-        # Pour les tests et la synchronisation, on veut tous les patches dans l'ordre
+        # 2. Apply only "staged" patches from TOML
+        # "candidate" patches are excluded because they have not yet passed
+        # the validation process (tests) that occurs during patch merge
+        # Current patch is applied separately by apply_patch_complete_workflow
         release_file = ReleaseFile(next_version, self._releases_dir)
         if release_file.exists():
-            # get_patches() sans argument retourne TOUS les patches dans l'ordre d'insertion
-            all_toml_patches = release_file.get_patches()
-            all_patches.extend(all_toml_patches)
+            staged_patches = release_file.get_patches(status="staged")
+            all_patches.extend(staged_patches)
 
         return all_patches
 
@@ -2291,10 +2335,18 @@ class ReleaseManager:
             # 1. Apply patches to database (for validation)
             self._apply_release_patches(version)
 
-            # 2. Checkout release branch
+            # 2. Register the RC version in half_orm_meta.hop_release
+            version_parts = version.split('.')
+            major, minor, patch_num = map(int, version_parts)
+            self._repo.database.register_release(
+                major, minor, patch_num,
+                pre_release='rc', pre_release_num=str(rc_number)
+            )
+
+            # 3. Checkout release branch
             self._repo.hgit.checkout(release_branch)
 
-            # 3. Create RC tag on release branch
+            # 4. Create RC tag on release branch
             self._repo.hgit.create_tag(rc_tag, f"Release Candidate %{version}")
 
             # Push tag
@@ -2310,14 +2362,10 @@ class ReleaseManager:
 
             # Keep TOML file for continued development (don't delete it)
 
-            # Generate data-X.Y.Z-rcN.sql if any patches have @HOP:data files
-            rc_patches = self.read_release_patches(rc_file.name)
-            data_file = self._generate_data_sql_file(
-                rc_patches,
-                f"data-{version}-rc{rc_number}.sql"
-            )
+            # Note: data-X.Y.Z.sql is only generated for production releases
+            # RC releases don't need it - data is inserted via patch application
 
-            # Commit RC snapshot and data file (both in .hop/releases/)
+            # Commit RC snapshot (in .hop/releases/)
             # This also syncs .hop/ to all active branches automatically
             self._repo.commit_and_sync_to_active_branches(
                 message=f"[HOP] Promote release %{version} to RC {rc_number}"
@@ -2474,6 +2522,11 @@ class ReleaseManager:
                 # The database should already be in the correct state from RC
                 pass
 
+            # Register the release version in half_orm_meta.hop_release
+            version_parts = version.split('.')
+            major, minor, patch_num = map(int, version_parts)
+            self._repo.database.register_release(major, minor, patch_num)
+
             # Generate schema dump for this production version
             model_dir = Path(self._repo.model_dir)
             self._repo.database._generate_schema_sql(version, model_dir)
@@ -2489,13 +2542,12 @@ class ReleaseManager:
             if toml_file.exists():
                 toml_file.unlink()
 
-            # Generate data-X.Y.Z.sql if any patches have @HOP:data files
-            # This includes patches from stage (incremental after last RC)
+            # Generate model/data-X.Y.Z.sql if any patches have @HOP:data files
+            # This file is used for from-scratch installations (clone, restore)
             prod_patches = self.read_release_patches(prod_file.name)
-            self._generate_data_sql_file(
-                prod_patches,
-                f"data-{version}.sql"
-            )
+            data_file = self._generate_data_sql_file(prod_patches, version)
+            if data_file:
+                self._repo.hgit.add(str(data_file))
 
             self._repo.commit_and_sync_to_active_branches(
                 message=f"[HOP] Promote release %{version} to production",
@@ -2910,14 +2962,12 @@ class ReleaseManager:
                 if toml_file.exists():
                     self._repo.hgit.rm(str(toml_file))
 
-            # Generate data-X.Y.Z-hotfixN.sql if any patches have @HOP:data files
-            hotfix_patches = self.read_release_patches(hotfix_file.name)
-            data_file = self._generate_data_sql_file(
-                hotfix_patches,
-                f"data-{version}-hotfix{hotfix_num}.sql"
-            )
+            # Regenerate model/data-X.Y.Z.sql with all patches (original release + all hotfixes)
+            # This ensures from-scratch installations get all data
+            all_patches = self._collect_all_version_patches(version)
+            data_file = self._generate_data_sql_file(all_patches, version)
             if data_file:
-                self._repo.hgit.add(str(data_file))  # Add data file if generated
+                self._repo.hgit.add(str(data_file))
 
             # 6. Apply release patches and generate SQL dumps
             self._apply_release_patches(version, True)
@@ -2954,3 +3004,248 @@ class ReleaseManager:
             raise
         except Exception as e:
             raise ReleaseManagerError(f"Failed to promote hotfix: {e}")
+
+    def get_all_release_patches_for_testing(self) -> List[str]:
+        """
+        Get ALL patches for integration testing (candidates + staged).
+
+        Unlike get_all_release_context_patches() which excludes candidates,
+        this method returns ALL patches including those not yet validated.
+        Used by 'release apply' for complete integration testing.
+
+        Returns:
+            Ordered list of ALL patch IDs (RC + candidates + staged)
+
+        Examples:
+            # Production: 1.3.5
+            # 1.3.6-rc1.txt: 123, 456, 789
+            # 1.3.6-patches.toml: {"234": "candidate", "567": "staged"}
+
+            patches = mgr.get_all_release_patches_for_testing()
+            # → ["123", "456", "789", "234", "567"]
+            # All patches included for complete integration testing
+        """
+        next_version = self.get_next_release_version()
+
+        if not next_version:
+            return []
+
+        all_patches = []
+
+        # 1. Apply all RCs in order (incremental)
+        rc_files = self._get_label_files(next_version, 'rc')
+        for rc_file in rc_files:
+            patches = self.read_release_patches(rc_file)
+            all_patches.extend(patches)
+
+        # 2. Apply ALL patches from TOML (candidates + staged)
+        # For integration testing, we want to test the complete release
+        release_file = ReleaseFile(next_version, self._releases_dir)
+        if release_file.exists():
+            all_toml_patches = release_file.get_patches()  # No status filter = all
+            all_patches.extend(all_toml_patches)
+
+        return all_patches
+
+    def _cleanup_validate_branch(self, original_branch: Optional[str],
+                                  validate_branch: Optional[str]) -> None:
+        """
+        Cleanup temporary validation branch after apply_release.
+
+        Switches back to the original branch and deletes the temporary
+        validation branch. Errors are silently ignored for robustness.
+
+        Args:
+            original_branch: Branch to switch back to (may be None)
+            validate_branch: Temporary branch to delete (may be None)
+        """
+        try:
+            if original_branch:
+                self._repo.hgit.checkout(original_branch)
+        except Exception:
+            pass  # Best effort
+
+        try:
+            if validate_branch:
+                self._repo.hgit.delete_branch(validate_branch, force=True)
+        except Exception:
+            pass  # Best effort
+
+    def apply_release(self, run_tests: bool = True) -> dict:
+        """
+        Apply all patches from current release for integration testing.
+
+        Creates a temporary validation branch (ho-validate/release-X.Y.Z),
+        merges candidate patch branches, restores the database, applies ALL
+        patches (including candidates), optionally runs tests, then cleans up.
+        This simulates a complete release merge without modifying the release branch.
+
+        Unlike 'patch apply' which only applies staged patches,
+        'release apply' applies ALL patches (candidates + staged) to
+        validate the complete integration.
+
+        Args:
+            run_tests: Whether to run pytest after applying patches (default: True)
+
+        Returns:
+            Dict containing:
+            - version: Release version being tested
+            - patches_applied: List of patch IDs applied
+            - candidates_merged: List of candidate patch branches merged
+            - files_applied: List of SQL/Python files applied
+            - tests_passed: Boolean (None if tests not run)
+            - test_output: Test output (None if tests not run)
+            - status: 'success' or 'failed'
+            - error: Error message if failed
+
+        Raises:
+            ReleaseManagerError: If no release in development or apply fails
+
+        Workflow:
+            1. Detect current development release
+            2. Validate we're on release branch
+            3. Create temporary validation branch
+            4. Merge candidate patch branches (simulate future merges)
+            5. Restore database from production schema
+            6. Apply ALL patches (RC + staged + candidates)
+            7. Generate Python code
+            8. Optionally run tests
+            9. Cleanup: switch back and delete temp branch
+            10. Return results
+
+        Examples:
+            # Test current release with tests
+            result = release_mgr.apply_release()
+            if result['status'] == 'success':
+                print(f"Release {result['version']} ready!")
+
+            # Test without running tests
+            result = release_mgr.apply_release(run_tests=False)
+        """
+        import subprocess
+
+        validate_branch = None
+        original_branch = None
+
+        try:
+            # 1. Detect current development release
+            next_version = self.get_next_release_version()
+            if not next_version:
+                raise ReleaseManagerError(
+                    "No development release found.\n"
+                    "Create one with: half_orm dev release create <level>"
+                )
+
+            # 2. Validate we're on a release branch
+            original_branch = self._repo.hgit.branch
+            expected_branch = f"ho-release/{next_version}"
+            if original_branch != expected_branch:
+                raise ReleaseManagerError(
+                    f"Must be on release branch {expected_branch}\n"
+                    f"Currently on: {original_branch}\n"
+                    f"Switch with: git checkout {expected_branch}"
+                )
+
+            # 3. Create temporary validation branch
+            validate_branch = f"ho-validate/release-{next_version}"
+
+            # Delete existing validation branch if it exists
+            try:
+                self._repo.hgit.delete_branch(validate_branch, force=True)
+            except Exception:
+                pass  # Branch doesn't exist, that's fine
+
+            # Create and checkout validation branch
+            self._repo.hgit.create_branch(validate_branch)
+            self._repo.hgit.checkout(validate_branch)
+
+            # 4. Merge candidate patch branches to simulate future merges
+            # Staged patches are already merged on ho-release, only candidates need merging
+            release_file = ReleaseFile(next_version, self._releases_dir)
+            candidates_merged = []
+            if release_file.exists():
+                candidate_patches = release_file.get_patches(status="candidate")
+                for patch_id in candidate_patches:
+                    patch_branch = f"ho-patch/{patch_id}"
+                    try:
+                        self._repo.hgit.merge(patch_branch)
+                        candidates_merged.append(patch_id)
+                    except Exception as e:
+                        raise ReleaseManagerError(
+                            f"Failed to merge candidate branch {patch_branch}: {e}\n"
+                            f"Fix merge conflicts on the patch branch first."
+                        )
+
+            # 5. Restore database from production schema
+            self._repo.restore_database_from_schema()
+
+            # 6. Get and apply ALL patches (RC + staged + candidates)
+            all_patches = self.get_all_release_patches_for_testing()
+            all_applied_files = []
+
+            for patch_id in all_patches:
+                files = self._repo.patch_manager.apply_patch_files(
+                    patch_id, self._repo.model
+                )
+                all_applied_files.extend(files)
+
+            # 7. Generate Python code
+            from half_orm_dev import modules
+            modules.generate(self._repo)
+
+            # 8. Optionally run tests
+            tests_passed = None
+            test_output = None
+
+            if run_tests:
+                try:
+                    result = subprocess.run(
+                        ['pytest', '-v'],
+                        cwd=self._repo.base_dir,
+                        capture_output=True,
+                        text=True,
+                        timeout=600  # 10 minute timeout
+                    )
+                    tests_passed = result.returncode == 0
+                    test_output = result.stdout + result.stderr
+                except subprocess.TimeoutExpired:
+                    tests_passed = False
+                    test_output = "Tests timed out after 10 minutes"
+                except FileNotFoundError:
+                    tests_passed = None
+                    test_output = "pytest not found - tests skipped"
+
+            # 9. Cleanup: switch back to original branch and delete temp branch
+            self._repo.hgit.checkout(original_branch)
+            try:
+                self._repo.hgit.delete_branch(validate_branch, force=True)
+            except Exception:
+                pass  # Best effort cleanup
+
+            # 10. Return results
+            return {
+                'version': next_version,
+                'patches_applied': all_patches,
+                'candidates_merged': candidates_merged,
+                'files_applied': all_applied_files,
+                'tests_passed': tests_passed,
+                'test_output': test_output,
+                'status': 'success' if tests_passed is not False else 'failed',
+                'error': None
+            }
+
+        except ReleaseManagerError:
+            # Cleanup on error
+            self._cleanup_validate_branch(original_branch, validate_branch)
+            raise
+        except Exception as e:
+            # Cleanup on error
+            self._cleanup_validate_branch(original_branch, validate_branch)
+
+            # Restore DB to clean state on failure
+            try:
+                self._repo.restore_database_from_schema()
+            except Exception:
+                pass  # Best effort cleanup
+
+            raise ReleaseManagerError(f"Release apply failed: {e}")