diff --git a/backend/web.py b/backend/web.py index 461ffe6..e1ce8d8 100644 --- a/backend/web.py +++ b/backend/web.py @@ -11,7 +11,7 @@ from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import FileResponse from app import App -from enironment import get_step +from enironment import SharedStateConflictError, get_step from utils import custom_json_dumps from processing import reset_caches from secondary import SecondaryManager @@ -186,14 +186,28 @@ class WebApp: elif id in self.core.environments.keys(): env = self.core.environments.get(id, None) expected_token = update_data.get('token', '') - if 'branches' in update_data: - if not env: - raise RuntimeError(f"Unknown env {update_data.get('id', '')}") - env.state.set_branches(update_data.get('branches', []), expected_token=expected_token) - if 'dry' in update_data: - if not env: - raise RuntimeError(f"Unknown env {update_data.get('id', '')}") - env.state.set_dry(bool(update_data['dry']), expected_token) + try: + if 'branches' in update_data: + if not env: + raise RuntimeError(f"Unknown env {update_data.get('id', '')}") + env.state.set_branches(update_data.get('branches', []), expected_token=expected_token) + if 'dry' in update_data: + if not env: + raise RuntimeError(f"Unknown env {update_data.get('id', '')}") + env.state.set_dry(bool(update_data['dry']), expected_token) + except SharedStateConflictError as conflict: + # if env: + # current_state = env.state.progress() + # await self.broadcast_error({ + # 'code': 'BRANCH_STATE_CONFLICT', + # 'envId': id, + # 'message': str(conflict), + # 'current_state': { + # 'branches': current_state.branches, + # 'token': current_state.token, + # }, + # }) + continue if env: p = get_step(env.pipeline, type(env.state)) diff --git a/frontend/app.js b/frontend/app.js index 69a3669..02f6e1d 100644 --- a/frontend/app.js +++ b/frontend/app.js @@ -137,9 +137,20 @@ function escapeHtml(str) { } let renderedBranches = [] +let renderedDryRunState = {} +let renderedColumnsSignature = '' + +function getColumnsSignature() { + return JSON.stringify(columnsByEnv); +} function renderBranches() { - if (JSON.stringify(filteredBranches) === JSON.stringify(renderedBranches) && JSON.stringify(dryRunByEnv) === JSON.stringify(renderedDryRunState)) { + const columnsSignature = getColumnsSignature(); + if ( + JSON.stringify(filteredBranches) === JSON.stringify(renderedBranches) && + JSON.stringify(dryRunByEnv) === JSON.stringify(renderedDryRunState) && + columnsSignature === renderedColumnsSignature + ) { return } checkForPendingChanges(); @@ -252,8 +263,9 @@ function renderBranches() { filterBranches(); }; }); - renderedBranches = filteredBranches; + renderedBranches = [...filteredBranches]; renderedDryRunState = {...dryRunByEnv}; + renderedColumnsSignature = columnsSignature; } function updateBranchCommit(envId, branch, commit) { @@ -470,9 +482,13 @@ function setupWebSockets() { if (message.error && message.error.code === 'BRANCH_STATE_CONFLICT' && message.error.envId) { const envId = message.error.envId; const current = message.error.current_state || {}; + const hadLocalSelection = Object.prototype.hasOwnProperty.call(selectedBranchesByEnv, envId); if (Array.isArray(current.branches)) { - selectedBranchesByEnv[envId] = [...current.branches]; serverSelectedBranchesByEnv[envId] = [...current.branches]; + // Preserve the user's pending edits if they already changed selection locally. + if (!hadLocalSelection) { + selectedBranchesByEnv[envId] = [...current.branches]; + } } if (typeof current.token === 'string') { serverTokenByEnv[envId] = current.token; @@ -503,6 +519,8 @@ function updateEnvironment() { if (JSON.stringify(localSel) !== JSON.stringify(serverSel)) { if (ws && ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify({ update: { id: envId, branches: selectedBranchesByEnv[envId], token: serverTokenByEnv[envId] } })); + // Keep pending-state tracking aligned with what we just submitted. + serverSelectedBranchesByEnv[envId] = [...(selectedBranchesByEnv[envId] || [])]; } branchFilter.value = ''; } diff --git a/tests/playwright_helper.py b/tests/playwright_helper.py index 1c2172c..ef260b4 100644 --- a/tests/playwright_helper.py +++ b/tests/playwright_helper.py @@ -20,6 +20,25 @@ class BrencherPage: button.wait_for(state="visible", timeout=10000) return button + def _apply_changes_button(self) -> Locator: + button = self._page.locator("#apply-changes") + button.wait_for(state="visible", timeout=10000) + return button + + def _branch_checkbox(self, branch_name: str) -> Locator: + checkbox = self._page.locator( + f'input[type="checkbox"][data-env="{self._env_id}"][value="{branch_name}"]' + ) + checkbox.wait_for(state="visible", timeout=10000) + return checkbox + + def _desired_commit_select(self, branch_name: str) -> Locator: + select = self._page.locator( + f'select.desired-commit[data-env="{self._env_id}"][data-branch="{branch_name}"]' + ) + select.wait_for(state="visible", timeout=10000) + return select + def verify_dry_run_on(self) -> None: btn_title = self._dry_run_button().get_attribute("title") or "" assert "Dry run on" in btn_title, f"Expected dry run to be active, got title: {btn_title!r}" @@ -29,6 +48,39 @@ class BrencherPage: self._dry_run_button().click() self._logger.info("Clicked dry-run button to disable dry run") + def set_branch_unselected(self, branch_name: str) -> None: + checkbox = self._branch_checkbox(branch_name) + if checkbox.is_checked(): + checkbox.uncheck() + self._logger.info("Unchecked branch '%s'", branch_name) + + def set_branch_desired_commit(self, branch_name: str, commit_hash: str) -> None: + self._desired_commit_select(branch_name).select_option(value=commit_hash) + self._logger.info("Set desired commit for branch '%s' to '%s'", branch_name, commit_hash) + + def set_apply_changes(self) -> None: + self._apply_changes_button().click() + self._logger.info("Clicked Apply Changes") + + def set_simulate_branch_state_conflict(self) -> None: + self._page.evaluate( + """({ envId }) => { + const currentToken = + (typeof serverTokenByEnv !== 'undefined' && serverTokenByEnv[envId]) + ? serverTokenByEnv[envId] + : 'server-token'; + const staleToken = `${currentToken}-stale`; + if (typeof serverTokenByEnv !== 'undefined') { + // Simulate stale client-side token so next apply uses an outdated value. + serverTokenByEnv[envId] = staleToken; + } + }""", + { + "envId": self._env_id, + }, + ) + self._logger.info("Set stale branch token for '%s'", self._env_id) + def click_refresh(self) -> None: self._page.locator("#refresh-branches").click() self._logger.info("Clicked refresh button") @@ -46,6 +98,55 @@ class BrencherPage: timeout=10000, ) + def verify_apply_changes_visible(self) -> None: + self._page.wait_for_function( + """() => { + const btn = document.querySelector('#apply-changes'); + return !!btn && !btn.classList.contains('hidden'); + }""", + timeout=10000, + ) + self._logger.info("Apply Changes button is visible") + + def verify_apply_changes_hidden(self) -> None: + self._page.wait_for_function( + """() => { + const btn = document.querySelector('#apply-changes'); + return !!btn && btn.classList.contains('hidden'); + }""", + timeout=10000, + ) + self._logger.info("Apply Changes button is hidden") + + def verify_branch_column_value(self, branch_name: str, column_name: str, expected_value: str, timeout_ms: int = 10000) -> None: + self._page.wait_for_function( + """({ envId, branchName, columnName, expectedValue }) => { + const row = document.querySelector(`tr.branch-row[data-env="${envId}"][data-branch="${branchName}"]`); + if (!row) return false; + const table = row.closest('table.branches-table'); + if (!table) return false; + const headers = [...table.querySelectorAll('thead th')].map(th => (th.textContent || '').trim()); + const colIdx = headers.indexOf(columnName); + if (colIdx === -1) return false; + const cells = [...row.querySelectorAll('td')]; + if (cells.length <= colIdx) return false; + return ((cells[colIdx].textContent || '').trim() === expectedValue); + }""", + arg={ + "envId": self._env_id, + "branchName": branch_name, + "columnName": column_name, + "expectedValue": expected_value, + }, + timeout=timeout_ms, + ) + self._logger.info( + "Verified column '%s' for branch '%s' equals '%s'", + column_name, + branch_name, + expected_value, + ) + def verify_pipeline_step_status(self, step_name: str, expected_status: str, timeout_ms: int = 10000) -> None: """ Verify that a pipeline step reaches the expected status by polling the page DOM. diff --git a/tests/test_apply_changes.py b/tests/test_apply_changes.py new file mode 100644 index 0000000..5196798 --- /dev/null +++ b/tests/test_apply_changes.py @@ -0,0 +1,127 @@ +import logging +import threading +import time +from typing import Any, Generator + +import docker +import pytest +import requests +import socket + +from app import App +from tests.configs import nginx +from tests.conftest import EventuallyFn, assert_equal +from tests.playwright_helper import brencher_page + + +logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') +logger = logging.getLogger(__name__) + +APP_PORT = 5003 +APP_URL = f"http://localhost:{APP_PORT}" +CONTAINER_NAME = "test_plain-container" + +# Module-level reference to server thread to ensure proper cleanup +_server_thread: threading.Thread | None = None + + +def _is_port_free(port: int, timeout: float = 5.0) -> bool: + """Check if a port is available for binding.""" + deadline = time.time() + timeout + while time.time() < deadline: + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + result = sock.connect_ex(('127.0.0.1', port)) + sock.close() + if result != 0: + return True + except Exception: + return True + time.sleep(0.1) + return False + + +class TestApplyChangesPlaywright: + + @pytest.fixture(autouse=True) + def setup_teardown(self) -> Generator[None, Any, None]: + global _server_thread + + def stop_and_remove_container() -> None: + client = docker.from_env() + try: + container = client.containers.get(CONTAINER_NAME) + container.stop(timeout=10) + container.remove(force=True) + logger.info("Container %s stopped and removed", CONTAINER_NAME) + except Exception: + logger.info("Container %s not found, no need to stop/remove", CONTAINER_NAME) + + # Ensure port is free before starting + _is_port_free(APP_PORT, timeout=5.0) + + stop_and_remove_container() + yield None + + # Clean up server thread + if _server_thread and _server_thread.is_alive(): + _server_thread.join(timeout=2.0) + logger.info("Waited for server thread to finish") + + # Ensure port is free after test + _is_port_free(APP_PORT, timeout=5.0) + + stop_and_remove_container() + _server_thread = None + + def test_apply_button_hides_after_apply_branch_change(self, eventually: EventuallyFn) -> None: + global _server_thread + + # Start app with one pre-selected branch so unchecking creates pending changes. + env = nginx.test_local1 + env.state.set_branches([("test/main", "HEAD")]) + env.state.set_dry(True) + app = App({env.id: env}) + _server_thread = threading.Thread(target=lambda: app.runWeb(APP_PORT), daemon=True) + _server_thread.start() + + eventually( + lambda: assert_equal( + requests.get(f"{APP_URL}/state", timeout=5).status_code, + 200, + "Server did not respond with 200 OK within timeout", + ) + ) + + with brencher_page(APP_URL, env.id) as page: + page.set_branch_unselected("test/main") + page.verify_apply_changes_visible() + page.set_apply_changes() + eventually(lambda: page.verify_apply_changes_hidden(), timeout=10, interval=0.5) + + def test_apply_button_reappears_on_branch_conflict(self, eventually: EventuallyFn) -> None: + global _server_thread + + env = nginx.test_local1 + env.state.set_branches([("test/main", "HEAD")]) + env.state.set_dry(True) + app = App({env.id: env}) + _server_thread = threading.Thread(target=lambda: app.runWeb(APP_PORT), daemon=True) + _server_thread.start() + + eventually( + lambda: assert_equal( + requests.get(f"{APP_URL}/state", timeout=5).status_code, + 200, + "Server did not respond with 200 OK within timeout", + ) + ) + + with brencher_page(APP_URL, env.id) as page: + page.set_branch_unselected("test/main") + page.verify_apply_changes_visible() + # Set stale token in client JS object so backend returns a real conflict on apply. + page.set_simulate_branch_state_conflict() + page.set_apply_changes() + eventually(lambda: page.verify_apply_changes_visible(), timeout=10, interval=0.5) diff --git a/tests/test_deploy_column_playwright.py b/tests/test_deploy_column_playwright.py new file mode 100644 index 0000000..a6f0f55 --- /dev/null +++ b/tests/test_deploy_column_playwright.py @@ -0,0 +1,182 @@ +import logging +import socket +import threading +import time +from typing import Any, Generator + +import docker +import pytest +import requests + +from app import App +from tests.configs import nginx +from tests.conftest import EventuallyFn, assert_equal +from tests.playwright_helper import brencher_page + + +logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') +logger = logging.getLogger(__name__) + +APP_PORT = 5004 +APP_URL = f"http://localhost:{APP_PORT}" +CONTAINER_NAME = "test_plain-container" +TARGET_BRANCH = "test/main" + +_server_thread: threading.Thread | None = None + + +def _is_port_free(port: int, timeout: float = 5.0) -> bool: + """Check if a port is available for binding.""" + deadline = time.time() + timeout + while time.time() < deadline: + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + result = sock.connect_ex(("127.0.0.1", port)) + sock.close() + if result != 0: + return True + except Exception: + return True + time.sleep(0.1) + return False + + +def _get_state() -> dict[str, Any]: + response = requests.get(f"{APP_URL}/state", timeout=5) + assert response.status_code == 200, f"Expected status 200 from /state, got {response.status_code}" + data = response.json() + assert isinstance(data, dict), f"Expected dict from /state, got {type(data)}" + return data + + +def _get_deployed_short_hash(env_id: str, branch: str) -> str: + state = _get_state() + env_state = state.get(env_id) + assert isinstance(env_state, dict), f"No environment state for {env_id}: {state}" + + pipeline = env_state.get("pipeline") + assert isinstance(pipeline, list), f"Pipeline is not list for {env_id}: {env_state}" + + step = next((p for p in pipeline if p.get("name") == "GitUnmerge"), None) + assert isinstance(step, dict), f"GitUnmerge step not found in pipeline: {pipeline}" + assert not bool(step.get("is_running")), f"GitUnmerge is still running: {step}" + + status = step.get("status") + assert isinstance(status, dict), f"GitUnmerge status is not an object: {status}" + + columns = status.get("columns") + assert isinstance(columns, dict), f"GitUnmerge columns missing: {status}" + + deployed = columns.get("Deployed") + assert isinstance(deployed, dict), f"Deployed column missing: {columns}" + + value = deployed.get(branch) + assert isinstance(value, str) and len(value) == 8, f"Deployed value for {branch} invalid: {value}" + return value + + +def _pick_target_commit(env_id: str, branch: str) -> str: + response = requests.get(f"{APP_URL}/branches", timeout=5) + assert response.status_code == 200, f"Expected status 200 from /branches, got {response.status_code}" + data = response.json() + assert isinstance(data, dict), f"Expected dict from /branches, got {type(data)}" + + env_branches = data.get(env_id, {}) + assert isinstance(env_branches, dict), f"Expected env branch map for {env_id}, got {env_branches}" + + commits = env_branches.get(branch, []) + assert isinstance(commits, list), f"Expected commits list for {branch}, got {commits}" + + for commit in commits: + if not isinstance(commit, dict): + continue + hexsha = commit.get("hexsha") + if isinstance(hexsha, str) and len(hexsha) >= 8: + return hexsha + + raise AssertionError(f"Unable to find any commit for branch {branch}.") + + +def _assert_deployed_hash_available(env_id: str, branch: str) -> None: + value = _get_deployed_short_hash(env_id, branch) + assert isinstance(value, str) and len(value) == 8 + + +class TestDeployColumnPlaywright: + + @pytest.fixture(autouse=True) + def setup_teardown(self) -> Generator[None, Any, None]: + global _server_thread + + def stop_and_remove_container() -> None: + client = docker.from_env() + try: + container = client.containers.get(CONTAINER_NAME) + container.stop(timeout=10) + container.remove(force=True) + logger.info("Container %s stopped and removed", CONTAINER_NAME) + except Exception: + logger.info("Container %s not found, no need to stop/remove", CONTAINER_NAME) + + _is_port_free(APP_PORT, timeout=5.0) + + stop_and_remove_container() + yield None + + if _server_thread and _server_thread.is_alive(): + _server_thread.join(timeout=2.0) + logger.info("Waited for server thread to finish") + + _is_port_free(APP_PORT, timeout=5.0) + stop_and_remove_container() + _server_thread = None + + def test_deployed_column_updates_after_apply_changes_and_deploy(self, eventually: EventuallyFn) -> None: + global _server_thread + + env = nginx.test_local1 + env.state.set_branches([(TARGET_BRANCH, "HEAD")]) + env.state.set_dry(True) + + app = App({env.id: env}) + _server_thread = threading.Thread(target=lambda: app.runWeb(APP_PORT), daemon=True) + _server_thread.start() + + eventually( + lambda: assert_equal( + requests.get(f"{APP_URL}/state", timeout=5).status_code, + 200, + "Server did not respond with 200 OK within timeout", + ), + timeout=20, + interval=0.5, + ) + + target_commit = _pick_target_commit(env.id, TARGET_BRANCH) + + with brencher_page(APP_URL, env.id) as page: + page.verify_dry_run_on() + page.set_branch_desired_commit(TARGET_BRANCH, target_commit) + page.verify_apply_changes_visible() + page.set_apply_changes() + + eventually(lambda: page.verify_apply_changes_hidden(), timeout=20, interval=0.5) + + page.set_dry_run_off() + eventually(lambda: page.verify_dry_run_off(), timeout=20, interval=0.5) + page.click_refresh() + + eventually( + lambda: _assert_deployed_hash_available(env.id, TARGET_BRANCH), + timeout=90, + interval=1.0, + ) + + deployed_short_hash = _get_deployed_short_hash(env.id, TARGET_BRANCH) + + eventually( + lambda: page.verify_branch_column_value(TARGET_BRANCH, "Deployed", deployed_short_hash), + timeout=30, + interval=0.5, + ) diff --git a/tests/test_dry_run_playwright.py b/tests/test_dry_run_playwright.py index e4d0894..9527c8a 100644 --- a/tests/test_dry_run_playwright.py +++ b/tests/test_dry_run_playwright.py @@ -1,5 +1,7 @@ import logging import threading +import time +import socket from typing import Any, Callable, Generator, TypeVar import docker @@ -17,10 +19,32 @@ APP_PORT = 5003 APP_URL = f"http://localhost:{APP_PORT}" CONTAINER_NAME = "test_plain-container" +# Module-level reference to server thread to ensure proper cleanup +_server_thread: threading.Thread | None = None + + +def _is_port_free(port: int, timeout: float = 5.0) -> bool: + """Check if a port is available for binding.""" + deadline = time.time() + timeout + while time.time() < deadline: + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + result = sock.connect_ex(('127.0.0.1', port)) + sock.close() + if result != 0: + return True + except Exception: + return True + time.sleep(0.1) + return False + class TestDryRunPlaywright: @pytest.fixture(autouse=True) def setup_teardown(self) -> Generator[None, Any, None]: + global _server_thread + def stop_and_remove_container() -> None: client = docker.from_env() try: @@ -30,19 +54,35 @@ class TestDryRunPlaywright: logger.info(f"Container {CONTAINER_NAME} stopped and removed") except Exception: logger.info(f"Container {CONTAINER_NAME} not found, no need to stop/remove") + + # Ensure port is free before starting + _is_port_free(APP_PORT, timeout=5.0) + stop_and_remove_container() yield None + + # Clean up server thread + if _server_thread and _server_thread.is_alive(): + _server_thread.join(timeout=2.0) + logger.info("Waited for server thread to finish") + + # Ensure port is free after test + _is_port_free(APP_PORT, timeout=5.0) + stop_and_remove_container() + _server_thread = None def test_dry_run_prevents_deploy_until_disabled(self, eventually: EventuallyFn) -> None: + global _server_thread + # Start app with nginx_local1 with main branch pre-selected and dry mode on. env = nginx.test_local1 env.state.set_branches([("test/main", "HEAD")]) env.state.set_dry(True) app = App({env.id: env}) - server_thread = threading.Thread(target=lambda: app.runWeb(APP_PORT), daemon=True) - server_thread.start() + _server_thread = threading.Thread(target=lambda: app.runWeb(APP_PORT), daemon=True) + _server_thread.start() # Wait for server to be up eventually(lambda: assert_equal(requests.get(f"{APP_URL}/state", timeout=5).status_code, 200, "Server did not respond with 200 OK within timeout"))