git-p4son 0.3.2__tar.gz → 0.3.3__tar.gz

{git_p4son-0.3.2 → git_p4son-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.2
+Version: 0.3.3
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -335,7 +335,10 @@ own submits one at a time. Repeat `--user` to split out several people's changel
 It is equivalent to working out the numbers by hand and running
 `git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
 resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
-all behave exactly as they do for `sync`.
+all behave exactly as they do for `sync`. The clean-workspace checks and the pre-sync hooks are the one
+thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
+dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
+and not at all for a `--dry-run` or when there is nothing to sync.
 
 **Arguments:**
 - `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
@@ -639,12 +642,25 @@ clone, so no `chmod` is needed.
 #### block-while-running (pre-sync)
 
 Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
-has loaded:
+has loaded. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
 
 ```sh
 ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
 ```
 
+On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
+reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
+against the current directory and quietly produces a broken link.
+
+```powershell
+New-Item -ItemType SymbolicLink `
+  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
+  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
+```
+
+Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
+For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
+
 Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
 stays per-project:
 

{git_p4son-0.3.2 → git_p4son-0.3.3}/README.md

@@ -312,7 +312,10 @@ own submits one at a time. Repeat `--user` to split out several people's changel
 It is equivalent to working out the numbers by hand and running
 `git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
 resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
-all behave exactly as they do for `sync`.
+all behave exactly as they do for `sync`. The clean-workspace checks and the pre-sync hooks are the one
+thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
+dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
+and not at all for a `--dry-run` or when there is nothing to sync.
 
 **Arguments:**
 - `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
@@ -616,12 +619,25 @@ clone, so no `chmod` is needed.
 #### block-while-running (pre-sync)
 
 Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
-has loaded:
+has loaded. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
 
 ```sh
 ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
 ```
 
+On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
+reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
+against the current directory and quietly produces a broken link.
+
+```powershell
+New-Item -ItemType SymbolicLink `
+  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
+  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
+```
+
+Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
+For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
+
 Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
 stays per-project:
 

{git_p4son-0.3.2 → git_p4son-0.3.3}/git_p4son/__init__.py

@@ -7,6 +7,6 @@ creating and updating changelists, and managing Swarm reviews.
 
 CONFIG_DIR = '.git-p4son'
 
-__version__ = "0.3.2"
+__version__ = "0.3.3"
 __author__ = "Andreas Andersson"
 __email__ = "andreas@neoboid.com"

{git_p4son-0.3.2 → git_p4son-0.3.3}/git_p4son/sync.py

@@ -36,6 +36,9 @@ from .perforce import (
 )
 
 
+LAST_SYNCED_LABEL = 'last synced'
+
+
 @dataclass
 class LastSync:
     """Info about the most recent p4son sync commit."""
@@ -524,11 +527,50 @@ def _handle_clobber_warning(clobber: bool, workspace_dir: str) -> bool:
     return True
 
 
+def _check_git_workspace_clean(workspace_dir: str) -> bool:
+    """Report whether the git workspace has no uncommitted changes."""
+    log.heading('Checking git workspace')
+    dirty_files = get_dirty_files(workspace_dir)
+    if dirty_files:
+        for filename, change in dirty_files:
+            log.file_change(filename, change)
+        log.error('Workspace is not clean')
+        return False
+    log.success('clean')
+    return True
+
+
+def _check_p4_workspace_clean(depot_root: str, workspace_dir: str) -> bool:
+    """Report whether the p4 workspace has no git-tracked files opened.
+
+    Files opened in Perforce that git does not track cannot collide with the
+    commit a sync makes, so they only warrant a warning.
+    """
+    log.heading('Checking p4 workspace')
+    opened_files = p4_get_opened_files(depot_root, workspace_dir)
+    tracked_opened_files = [
+        (filename, change)
+        for filename, change in opened_files
+        if is_file_tracked(filename, workspace_dir)
+    ]
+    if tracked_opened_files:
+        for filename, change in tracked_opened_files:
+            log.file_change(filename, change)
+        log.error('Workspace has p4-opened files tracked by git')
+        return False
+    if opened_files:
+        log.warning(
+            f'Ignoring {len(opened_files)} p4-opened files not tracked by git')
+    else:
+        log.success('Clean')
+    return True
+
+
 def _run_pre_sync_hooks(workspace_dir: str, invocation_dir: str) -> bool:
     """Run pre-sync hooks; return False when any hook fails, aborting the sync.
 
-    Runs once before any changelist is synced. All hooks run (they are
-    independent), then the sync is aborted if any returned a non-zero code.
+    All hooks run (they are independent), then the sync is aborted if any
+    returned a non-zero code.
     """
     results = run_hooks('pre-sync', workspace_dir, invocation_dir)
     if any(result.returncode != 0 for result in results):
@@ -537,6 +579,26 @@ def _run_pre_sync_hooks(workspace_dir: str, invocation_dir: str) -> bool:
     return True
 
 
+def sync_preflight(depot_root: str, workspace_dir: str, invocation_dir: str,
+                   already_done: bool = False) -> bool:
+    """Gate a sync: both workspaces clean, then the pre-sync hooks.
+
+    Returns False when the sync must not go ahead. Callers run this once they
+    know a sync will actually be attempted, so that a run with nothing to sync
+    neither checks the workspaces nor fires the hooks. already_done covers a
+    caller that ran it before delegating here: sync-split runs it up front,
+    ahead of the p4 queries that resolve its changelist sequence, so neither
+    the checks nor the hooks happen twice.
+    """
+    if already_done:
+        return True
+    if not _check_git_workspace_clean(workspace_dir):
+        return False
+    if not _check_p4_workspace_clean(depot_root, workspace_dir):
+        return False
+    return _run_pre_sync_hooks(workspace_dir, invocation_dir)
+
+
 def _sync_pass(changelist: int, label: str, depot_root: str,
                workspace_dir: str, pre_sync_head_commit: str, temp_root: str,
                uses_crlf: bool, clobber: bool) -> WritableSyncFileSet:
@@ -587,10 +649,82 @@ def resolve_depot_root(workspace_dir: str) -> ResolvedDepot | None:
     return ResolvedDepot(depot_root=depot_root, client_spec=client_spec)
 
 
+def _latest_target(depot_root: str, workspace_dir: str) -> tuple[int, str]:
+    """Look up the latest submitted changelist as a sync target."""
+    log.heading('Finding latest changelist')
+    latest = get_latest_changelist(depot_root, workspace_dir)
+    log.success(f'CL {latest}')
+    return (latest, 'latest')
+
+
+def _resolve_sync_targets(
+        raw: list[str], last_sync: LastSync | None, depot_root: str,
+        workspace_dir: str, force: bool) -> list[tuple[int, str]] | None:
+    """Resolve the ordered (changelist, label) targets a sync will visit.
+
+    Returns None when the arguments are invalid, and an empty list when the
+    workspace already sits at the only changelist asked for.
+    """
+    lowered = [c.lower() for c in raw]
+
+    # "head" resolves to the latest changelist, the largest in an increasing
+    # sequence, so it may only appear as the final target.
+    if 'head' in lowered and lowered.index('head') != len(lowered) - 1:
+        log.error('The "head" keyword must come last')
+        return None
+
+    if not raw:
+        targets = [_latest_target(depot_root, workspace_dir)]
+    else:
+        targets = []
+        for c in raw:
+            if c.lower() == 'head':
+                targets.append(_latest_target(depot_root, workspace_dir))
+            else:
+                try:
+                    targets.append((int(c), 'specified'))
+                except ValueError:
+                    log.error(f'Invalid changelist number: {c}')
+                    return None
+
+    # Targets are synced in the given order, so they must be strictly
+    # increasing: no syncing back and forth.
+    numbers = [cl for cl, _ in targets]
+    for prev, curr in zip(numbers, numbers[1:]):
+        if curr <= prev:
+            log.error('Changelists must be strictly increasing, '
+                      f'got {prev} then {curr}')
+            return None
+
+    # Syncing to a changelist older than the current one needs --force.
+    # Targets are strictly increasing, so the smallest is numbers[0]; an
+    # equal-to-current changelist (dropped just below) is not "older".
+    if last_sync and numbers[0] < last_sync.changelist:
+        if not force:
+            log.error(
+                f'Cannot sync to CL {numbers[0]} '
+                f'(currently at CL {last_sync.changelist}) without --force.')
+            return None
+        log.warning(
+            f'Syncing to older CL {numbers[0]} '
+            f'(currently at CL {last_sync.changelist}) with --force')
+
+    # Drop a target equal to the last synced changelist: we are already
+    # there, so there is nothing to sync or commit for it. An explicitly
+    # requested *older* changelist is kept and synced as the user asked.
+    if last_sync and last_sync.changelist in numbers:
+        log.info(f'Skipping CL {last_sync.changelist} (already synced)')
+        targets = [(cl, lbl) for cl, lbl in targets
+                   if cl != last_sync.changelist]
+
+    return targets
+
+
 def sync_command(args: argparse.Namespace) -> int:
     """Execute the sync command."""
     workspace_dir = args.workspace_dir
     invocation_dir = vars(args).get('invocation_dir', workspace_dir)
+    preflight_done = vars(args).get('preflight_done', False)
 
     resolved = resolve_depot_root(workspace_dir)
     if resolved is None:
@@ -598,44 +732,40 @@ def sync_command(args: argparse.Namespace) -> int:
     depot_root = resolved.depot_root
     client_spec = resolved.client_spec
 
-    log.heading('Checking git workspace')
-    dirty_files = get_dirty_files(workspace_dir)
-    if dirty_files:
-        for filename, change in dirty_files:
-            log.file_change(filename, change)
-        log.error('Workspace is not clean')
-        return 1
-    log.success('clean')
-
-    log.heading('Checking p4 workspace')
-    opened_files = p4_get_opened_files(depot_root, workspace_dir)
-    tracked_opened_files = [
-        (filename, change)
-        for filename, change in opened_files
-        if is_file_tracked(filename, workspace_dir)
-    ]
-    if tracked_opened_files:
-        for filename, change in tracked_opened_files:
-            log.file_change(filename, change)
-        log.error('Workspace has p4-opened files tracked by git')
-        return 1
-    if opened_files:
-        log.warning(
-            f'Ignoring {len(opened_files)} p4-opened files not tracked by git')
-    else:
-        log.success('Clean')
-
-    last_changelist_label = 'last synced'
-    log.heading(f'Finding {last_changelist_label} changelist')
+    log.heading(f'Finding {LAST_SYNCED_LABEL} changelist')
     last_sync = git_last_sync(workspace_dir)
     if last_sync:
         log.success(f'CL {last_sync.changelist}')
     else:
         log.warning('No previous sync found')
 
-    log.heading('Finding HEAD commit')
-    pre_sync_head_commit = get_head_commit(workspace_dir)
-    log.success(f'{pre_sync_head_commit}')
+    # Work out what the sync will do before touching either workspace, so a
+    # run with nothing to sync gets through without checks or hooks.
+    lowered = [c.lower() for c in args.changelist]
+
+    # "last-synced" is a keyword that only makes sense on its own. It re-syncs
+    # the changelist git is already at rather than advancing, so it resolves
+    # to no targets and takes its own path further down.
+    resync_last_synced = 'last-synced' in lowered
+    targets: list[tuple[int, str]] = []
+    if resync_last_synced:
+        if lowered != ['last-synced']:
+            log.error('The "last-synced" keyword cannot be combined with '
+                      'other changelists')
+            return 1
+        if not last_sync:
+            log.error('No previous sync found, cannot use "last-synced"')
+            return 1
+    else:
+        resolved_targets = _resolve_sync_targets(
+            args.changelist, last_sync, depot_root, workspace_dir, args.force)
+        if resolved_targets is None:
+            return 1
+        if not resolved_targets:
+            log.info('Already synced, nothing to do.')
+            log.heading('Skipping post-sync hooks')
+            return 0
+        targets = resolved_targets
 
     # Workspace line ending governs how staged git content is normalized so
     # the post-sync merge doesn't conflict on LF-vs-CRLF differences alone.
@@ -645,112 +775,42 @@ def sync_command(args: argparse.Namespace) -> int:
     uses_crlf = bool(client_spec and client_spec.uses_crlf)
     clobber = bool(client_spec and client_spec.clobber)
 
+    # Prompted before the preflight so declining here costs nothing: no
+    # workspace queries, and no hooks fired for a sync that is abandoned.
     if not _handle_clobber_warning(clobber, workspace_dir):
         return 1
 
+    # The single gate: both workspaces clean, then the pre-sync hooks. Runs
+    # once for the whole sync, covering the catch-up pass as well, and is
+    # skipped outright when the caller (sync-split) already ran it.
+    if not sync_preflight(depot_root, workspace_dir, invocation_dir,
+                          preflight_done):
+        return 1
+
+    log.heading('Finding HEAD commit')
+    pre_sync_head_commit = get_head_commit(workspace_dir)
+    log.success(f'{pre_sync_head_commit}')
+
     # Temp root for staging HEAD/baseline file content between classification
     # and the post-sync merge. Cleaned up automatically on exit.
     with tempfile.TemporaryDirectory(prefix='git-p4son-sync-') as temp_root:
-        raw = args.changelist
-        lowered = [c.lower() for c in raw]
-
-        # "last-synced" is a keyword that only makes sense on its own.
-        if 'last-synced' in lowered:
-            if lowered != ['last-synced']:
-                log.error('The "last-synced" keyword cannot be combined with '
-                          'other changelists')
-                return 1
-            if not last_sync:
-                log.error('No previous sync found, cannot use "last-synced"')
-                return 1
-            if not _run_pre_sync_hooks(workspace_dir, invocation_dir):
-                return 1
-            _sync_pass(last_sync.changelist, last_changelist_label, depot_root,
+        if resync_last_synced:
+            _sync_pass(last_sync.changelist, LAST_SYNCED_LABEL, depot_root,
                        workspace_dir, pre_sync_head_commit, temp_root,
                        uses_crlf, clobber)
             run_hooks('post-sync', workspace_dir, invocation_dir)
             return 0
 
-        # "head" resolves to the latest changelist, the largest in an
-        # increasing sequence, so it may only appear as the final target.
-        if 'head' in lowered and lowered.index('head') != len(lowered) - 1:
-            log.error('The "head" keyword must come last')
-            return 1
-
-        # Resolve the ordered list of (changelist, label) targets to sync,
-        # replacing a trailing "head" with the concrete latest changelist so
-        # the increasing-order check below compares real numbers.
-        if not raw:
-            log.heading('Finding latest changelist')
-            latest = get_latest_changelist(depot_root, workspace_dir)
-            log.success(f'CL {latest}')
-            targets = [(latest, 'latest')]
-        else:
-            targets = []
-            for c in raw:
-                if c.lower() == 'head':
-                    log.heading('Finding latest changelist')
-                    latest = get_latest_changelist(depot_root, workspace_dir)
-                    log.success(f'CL {latest}')
-                    targets.append((latest, 'latest'))
-                else:
-                    try:
-                        targets.append((int(c), 'specified'))
-                    except ValueError:
-                        log.error(f'Invalid changelist number: {c}')
-                        return 1
-
-        # Targets are synced in the given order, so they must be strictly
-        # increasing: no syncing back and forth.
-        numbers = [cl for cl, _ in targets]
-        for prev, curr in zip(numbers, numbers[1:]):
-            if curr <= prev:
-                log.error('Changelists must be strictly increasing, '
-                          f'got {prev} then {curr}')
-                return 1
-
-        last_changelist = last_sync.changelist if last_sync else None
-
-        # Syncing to a changelist older than the current one needs --force.
-        # Targets are strictly increasing, so the smallest is numbers[0]; an
-        # equal-to-current changelist (dropped just below) is not "older".
-        if last_sync and numbers[0] < last_sync.changelist:
-            if not args.force:
-                log.error(
-                    f'Cannot sync to CL {numbers[0]} '
-                    f'(currently at CL {last_sync.changelist}) without --force.')
-                return 1
-            log.warning(
-                f'Syncing to older CL {numbers[0]} '
-                f'(currently at CL {last_sync.changelist}) with --force')
-
-        # Drop a target equal to the last synced changelist: we are already
-        # there, so there is nothing to sync or commit for it. An explicitly
-        # requested *older* changelist is kept and synced as the user asked.
-        if last_changelist is not None and last_changelist in numbers:
-            log.info(f'Skipping CL {last_changelist} (already synced)')
-            targets = [(cl, lbl) for cl, lbl in targets
-                       if cl != last_changelist]
-
-        if not targets:
-            log.info('Already synced, nothing to do.')
-            log.heading('Skipping post-sync hooks')
-            return 0
-
-        # Pre-sync hooks run once, before syncing any changelist (including the
-        # catch-up pass), and abort the whole sync if any of them fail.
-        if not _run_pre_sync_hooks(workspace_dir, invocation_dir):
-            return 1
-
         all_changed: list[ChangedFile] = []
         all_ignored: list[str] = []
+        last_changelist = last_sync.changelist if last_sync else None
 
         # Catch-up pass to the last synced changelist. This makes locally
         # modified (writable) files read-only and stages their content so the
         # post-sync merge can restore local changes; its result is folded into
         # the first target commit.
         if last_changelist is not None:
-            prep = _sync_pass(last_changelist, last_changelist_label,
+            prep = _sync_pass(last_changelist, LAST_SYNCED_LABEL,
                               depot_root, workspace_dir, pre_sync_head_commit,
                               temp_root, uses_crlf, clobber)
             all_changed.extend(prep.changed)

{git_p4son-0.3.2 → git_p4son-0.3.3}/git_p4son/sync_split.py

@@ -11,7 +11,9 @@ from .perforce import (
     get_p4_user,
     get_submitted_changes,
 )
-from .sync import git_last_sync, resolve_depot_root, sync_command
+from .sync import (
+    git_last_sync, resolve_depot_root, sync_command, sync_preflight,
+)
 
 
 def build_sync_targets(changes: list[P4Change], users: list[str],
@@ -70,6 +72,7 @@ def _resolve_users(args: argparse.Namespace, workspace_dir: str) -> list[str]:
 def sync_split_command(args: argparse.Namespace) -> int:
     """Execute the sync-split command."""
     workspace_dir = args.workspace_dir
+    invocation_dir = vars(args).get('invocation_dir', workspace_dir)
 
     resolved = resolve_depot_root(workspace_dir)
     if resolved is None:
@@ -108,6 +111,17 @@ def sync_split_command(args: argparse.Namespace) -> int:
                   'changelist.')
         return 1
 
+    # The workspace checks and pre-sync hooks run here rather than being left
+    # to sync_command, which only reaches them after all of the resolution
+    # below. That resolution costs several p4 round trips, so a dirty
+    # workspace or a hook vetoing the sync should get to say so first.
+    # sync_command is told it is done so none of it happens twice, and a dry
+    # run syncs nothing, so it skips the gate entirely.
+    if not args.dry_run:
+        if not sync_preflight(depot_root, workspace_dir, invocation_dir):
+            return 1
+        args.preflight_done = True
+
     users = _resolve_users(args, workspace_dir)
     if not users:
         return 1

{git_p4son-0.3.2 → git_p4son-0.3.3}/git_p4son.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.2
+Version: 0.3.3
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -335,7 +335,10 @@ own submits one at a time. Repeat `--user` to split out several people's changel
 It is equivalent to working out the numbers by hand and running
 `git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
 resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
-all behave exactly as they do for `sync`.
+all behave exactly as they do for `sync`. The clean-workspace checks and the pre-sync hooks are the one
+thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
+dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
+and not at all for a `--dry-run` or when there is nothing to sync.
 
 **Arguments:**
 - `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
@@ -639,12 +642,25 @@ clone, so no `chmod` is needed.
 #### block-while-running (pre-sync)
 
 Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
-has loaded:
+has loaded. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
 
 ```sh
 ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
 ```
 
+On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
+reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
+against the current directory and quietly produces a broken link.
+
+```powershell
+New-Item -ItemType SymbolicLink `
+  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
+  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
+```
+
+Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
+For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
+
 Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
 stays per-project:
 

{git_p4son-0.3.2 → git_p4son-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "git-p4son"
-version = "0.3.2"
+version = "0.3.3"
 description = "Utility for keeping a Perforce workspace and local git repo in sync"
 readme = "README.md"
 requires-python = ">=3.11"

{git_p4son-0.3.2 → git_p4son-0.3.3}/tests/test_sync.py

@@ -866,21 +866,23 @@ class TestSyncCommand(unittest.TestCase):
         rc = sync_command(args)
         self.assertEqual(rc, 1)
 
+    @mock.patch('git_p4son.sync.git_last_sync', return_value=None)
     @mock.patch('git_p4son.sync.get_dirty_files',
                 return_value=[('file.txt', 'modify')])
     @mock.patch('git_p4son.sync.get_depot_root', return_value='//myclient')
-    def test_dirty_git_workspace_aborts(self, _depot, _git_clean):
+    def test_dirty_git_workspace_aborts(self, _depot, _git_clean, _last_sync):
         args = mock.Mock(changelist=['100'], force=False, workspace_dir='/ws')
         rc = sync_command(args)
         self.assertEqual(rc, 1)
 
+    @mock.patch('git_p4son.sync.git_last_sync', return_value=None)
     @mock.patch('git_p4son.sync.is_file_tracked', return_value=True)
     @mock.patch('git_p4son.sync.get_dirty_files', return_value=[])
     @mock.patch('git_p4son.sync.p4_get_opened_files',
                 return_value=[('foo.txt', 'modify')])
     @mock.patch('git_p4son.sync.get_depot_root', return_value='//myclient')
     def test_dirty_p4_workspace_aborts(self, _depot, _p4clean, _git_clean,
-                                       _tracked):
+                                       _tracked, _last_sync):
         args = mock.Mock(changelist=['100'], force=False, workspace_dir='/ws')
         rc = sync_command(args)
         self.assertEqual(rc, 1)
@@ -943,12 +945,13 @@ class TestSyncCommand(unittest.TestCase):
 
     @mock.patch('git_p4son.sync._handle_clobber_warning', return_value=False)
     @mock.patch('git_p4son.sync.get_head_commit', return_value='def456')
+    @mock.patch('git_p4son.sync.get_latest_changelist', return_value=200)
     @mock.patch('git_p4son.sync.git_last_sync', return_value=None)
     @mock.patch('git_p4son.sync.p4_get_opened_files', return_value=[])
     @mock.patch('git_p4son.sync.get_dirty_files', return_value=[])
     @mock.patch('git_p4son.sync.get_depot_root', return_value='//myclient')
     def test_aborts_when_clobber_warning_declined(
-            self, _depot, _git_clean, _p4clean, _last_sync, _head,
+            self, _depot, _git_clean, _p4clean, _last_sync, _latest, _head,
             _warn):
         args = mock.Mock(changelist=[], force=False, workspace_dir='/ws')
         rc = sync_command(args)
@@ -961,12 +964,16 @@ class TestSyncCommand(unittest.TestCase):
     @mock.patch('git_p4son.sync.p4_get_opened_files', return_value=[])
     @mock.patch('git_p4son.sync.get_dirty_files', return_value=[])
     @mock.patch('git_p4son.sync.get_depot_root', return_value='//myclient')
-    def test_same_cl_is_noop(self, _depot, _git_clean, _p4clean,
+    def test_same_cl_is_noop(self, _depot, mock_git_clean, mock_p4clean,
                              mock_last_sync, _head, mock_run_hooks, mock_log):
         mock_last_sync.return_value = LastSync(changelist=100, commit='abc')
         args = mock.Mock(changelist=['100'], force=False, workspace_dir='/ws')
         rc = sync_command(args)
         self.assertEqual(rc, 0)
+        # Nothing to sync, so the whole preflight is skipped: no workspace
+        # queries and no hooks, not merely no hooks.
+        mock_git_clean.assert_not_called()
+        mock_p4clean.assert_not_called()
         mock_run_hooks.assert_not_called()
         mock_log.heading.assert_any_call('Skipping post-sync hooks')
 

{git_p4son-0.3.2 → git_p4son-0.3.3}/tests/test_sync_split.py

@@ -1,13 +1,15 @@
 """Tests for git_p4son.sync_split module."""
 
+import argparse
 import unittest
 from unittest import mock
 
 from git_p4son.perforce import P4Change
-from git_p4son.sync import LastSync, ResolvedDepot
+from git_p4son.sync import LastSync, ResolvedDepot, sync_preflight
 from git_p4son.sync_split import (
     build_sync_targets, sync_split_command,
 )
+from tests.helpers import make_run_result
 
 
 def _changes(*pairs):
@@ -97,7 +99,7 @@ class TestBuildSyncTargets(unittest.TestCase):
         self.assertEqual(targets, [101, 102, 103, 104, 105])
 
 
-class TestSyncMineCommand(unittest.TestCase):
+class TestSyncSplitCommand(unittest.TestCase):
 
     def setUp(self):
         patcher = mock.patch(
@@ -106,6 +108,11 @@ class TestSyncMineCommand(unittest.TestCase):
                                        client_spec=None))
         patcher.start()
         self.addCleanup(patcher.stop)
+        # The gate has its own tests; here it must simply not shell out.
+        gate = mock.patch('git_p4son.sync_split.sync_preflight',
+                          return_value=True)
+        gate.start()
+        self.addCleanup(gate.stop)
 
     def _args(self, **overrides):
         values = dict(changelist=None, user=None, dry_run=False,
@@ -221,6 +228,178 @@ class TestSyncMineCommand(unittest.TestCase):
         rc = sync_split_command(self._args())
         self.assertEqual(rc, 1)
 
+
+class TestSyncSplitPreSyncHooks(unittest.TestCase):
+    """The hooks must fire before the p4 round trips they exist to save,
+    exactly once, and never for a run that syncs nothing."""
+
+    def setUp(self):
+        patcher = mock.patch(
+            'git_p4son.sync_split.resolve_depot_root',
+            return_value=ResolvedDepot(depot_root='//myclient',
+                                       client_spec=None))
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def _args(self, **overrides):
+        values = dict(changelist=None, user=None, dry_run=False,
+                      workspace_dir='/ws', invocation_dir='/invoked')
+        values.update(overrides)
+        return argparse.Namespace(**values)
+
+    @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
+    @mock.patch('git_p4son.sync_split.get_submitted_changes')
+    @mock.patch('git_p4son.sync_split.get_p4_user', return_value='me')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    @mock.patch('git_p4son.sync_split.sync_preflight', return_value=True)
+    def test_hooks_run_before_the_expensive_queries(
+            self, mock_hooks, _last_sync, _latest, mock_user, mock_changes,
+            _sync):
+        """The p4 user and changes lookups must not happen until the hooks
+        have had their say."""
+        order = []
+        mock_hooks.side_effect = lambda *a, **k: order.append('hooks') or True
+        mock_user.side_effect = lambda *a: order.append('p4 info') or 'me'
+        mock_changes.side_effect = lambda *a: order.append('p4 changes') or []
+        rc = sync_split_command(self._args())
+        self.assertEqual(rc, 0)
+        self.assertEqual(order, ['hooks', 'p4 info', 'p4 changes'])
+
+    @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
+    @mock.patch('git_p4son.sync_split.get_submitted_changes', return_value=[])
+    @mock.patch('git_p4son.sync_split.get_p4_user', return_value='me')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    @mock.patch('git_p4son.sync_split.sync_preflight', return_value=True)
+    def test_sync_command_is_told_not_to_rerun_them(
+            self, _hooks, _last_sync, _latest, _user, _changes, _sync):
+        args = self._args()
+        sync_split_command(args)
+        self.assertTrue(args.preflight_done)
+
+    @mock.patch('git_p4son.sync_split.get_submitted_changes')
+    @mock.patch('git_p4son.sync_split.get_p4_user')
+    @mock.patch('git_p4son.sync_split.sync_command')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    @mock.patch('git_p4son.sync_split.sync_preflight', return_value=False)
+    def test_failing_hook_aborts_before_any_query(
+            self, _hooks, _last_sync, _latest, mock_sync, mock_user,
+            mock_changes):
+        rc = sync_split_command(self._args())
+        self.assertEqual(rc, 1)
+        mock_user.assert_not_called()
+        mock_changes.assert_not_called()
+        mock_sync.assert_not_called()
+
+    @mock.patch('git_p4son.sync_split.get_submitted_changes', return_value=[])
+    @mock.patch('git_p4son.sync_split.get_p4_user', return_value='me')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    @mock.patch('git_p4son.sync_split.sync_preflight')
+    def test_dry_run_does_not_fire_hooks(
+            self, mock_hooks, _last_sync, _latest, _user, _changes):
+        rc = sync_split_command(self._args(dry_run=True))
+        self.assertEqual(rc, 0)
+        mock_hooks.assert_not_called()
+
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=100)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    @mock.patch('git_p4son.sync_split.sync_preflight')
+    def test_nothing_to_sync_does_not_fire_hooks(
+            self, mock_hooks, _last_sync, _latest):
+        """Already at the target: sync skips its hooks in that case, and
+        so must sync-split."""
+        rc = sync_split_command(self._args())
+        self.assertEqual(rc, 0)
+        mock_hooks.assert_not_called()
+
+    @mock.patch('git_p4son.sync_split.sync_preflight')
+    @mock.patch('git_p4son.sync_split.git_last_sync', return_value=None)
+    def test_unsynced_workspace_does_not_fire_hooks(
+            self, _last_sync, mock_hooks):
+        rc = sync_split_command(self._args())
+        self.assertEqual(rc, 1)
+        mock_hooks.assert_not_called()
+
+
+class TestSyncPreflight(unittest.TestCase):
+    """The one gate both commands share: workspace checks then hooks, in
+    that order, and skipped wholesale when a caller already ran it."""
+
+    @mock.patch('git_p4son.sync.run_hooks')
+    @mock.patch('git_p4son.sync.p4_get_opened_files')
+    @mock.patch('git_p4son.sync.get_dirty_files')
+    def test_already_done_skips_everything(
+            self, mock_dirty, mock_opened, mock_run_hooks):
+        self.assertTrue(sync_preflight('//ws', '/ws', '/invoked', True))
+        mock_dirty.assert_not_called()
+        mock_opened.assert_not_called()
+        mock_run_hooks.assert_not_called()
+
+    @mock.patch('git_p4son.sync.run_hooks', return_value=[])
+    @mock.patch('git_p4son.sync.p4_get_opened_files', return_value=[])
+    @mock.patch('git_p4son.sync.get_dirty_files', return_value=[])
+    def test_clean_workspaces_run_the_hooks(
+            self, _dirty, _opened, mock_run_hooks):
+        self.assertTrue(sync_preflight('//ws', '/ws', '/invoked'))
+        mock_run_hooks.assert_called_once_with('pre-sync', '/ws', '/invoked')
+
+    @mock.patch('git_p4son.sync.run_hooks')
+    @mock.patch('git_p4son.sync.p4_get_opened_files')
+    @mock.patch('git_p4son.sync.get_dirty_files',
+                return_value=[('a.txt', 'modify')])
+    def test_dirty_git_stops_before_p4_and_hooks(
+            self, _dirty, mock_opened, mock_run_hooks):
+        self.assertFalse(sync_preflight('//ws', '/ws', '/invoked'))
+        mock_opened.assert_not_called()
+        mock_run_hooks.assert_not_called()
+
+    @mock.patch('git_p4son.sync.run_hooks')
+    @mock.patch('git_p4son.sync.is_file_tracked', return_value=True)
+    @mock.patch('git_p4son.sync.p4_get_opened_files',
+                return_value=[('a.txt', 'modify')])
+    @mock.patch('git_p4son.sync.get_dirty_files', return_value=[])
+    def test_dirty_p4_stops_before_hooks(
+            self, _dirty, _opened, _tracked, mock_run_hooks):
+        self.assertFalse(sync_preflight('//ws', '/ws', '/invoked'))
+        mock_run_hooks.assert_not_called()
+
+    @mock.patch('git_p4son.sync.run_hooks',
+                return_value=[make_run_result(returncode=1)])
+    @mock.patch('git_p4son.sync.p4_get_opened_files', return_value=[])
+    @mock.patch('git_p4son.sync.get_dirty_files', return_value=[])
+    def test_failing_hook_fails_the_gate(self, _dirty, _opened, _hooks):
+        self.assertFalse(sync_preflight('//ws', '/ws', '/invoked'))
+
+
+class TestSyncSplitCommandMultiUser(unittest.TestCase):
+
+    def setUp(self):
+        patcher = mock.patch(
+            'git_p4son.sync_split.resolve_depot_root',
+            return_value=ResolvedDepot(depot_root='//myclient',
+                                       client_spec=None))
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        # The gate has its own tests; here it must simply not shell out.
+        gate = mock.patch('git_p4son.sync_split.sync_preflight',
+                          return_value=True)
+        gate.start()
+        self.addCleanup(gate.stop)
+
+    def _args(self, **overrides):
+        values = dict(changelist=None, user=None, dry_run=False,
+                      workspace_dir='/ws')
+        values.update(overrides)
+        return mock.Mock(**values)
+
     @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
     @mock.patch('git_p4son.sync_split.get_submitted_changes')
     @mock.patch('git_p4son.sync_split.get_p4_user')