sync: Don't checkout if no worktree

Interleaved sync should not try checkout out a project if it's a mirror.

Change-Id: I2549faab197a3202d79a10e44b449b68d53e3fe7

subcmds/sync.py

@@ -2269,51 +2269,57 @@ later is required to fix a server side protocol bug.
         checkout_finish = None
         checkout_stderr = ""
 
-        if fetch_success and not opt.network_only:
+        if fetch_success:
-            checkout_start = time.time()
+            # We skip checkout if it's network-only or if the project has no
-            stderr_capture = io.StringIO()
+            # working tree (e.g., a mirror).
-            try:
+            if opt.network_only or not project.worktree:
-                with contextlib.redirect_stderr(stderr_capture):
+                checkout_success = True
-                    syncbuf = SyncBuffer(
+            else:
-                        project.manifest.manifestProject.config,
+                # This is a normal project that needs a checkout.
-                        detach_head=opt.detach_head,
+                checkout_start = time.time()
-                    )
+                stderr_capture = io.StringIO()
-                    local_half_errors = []
+                try:
-                    project.Sync_LocalHalf(
+                    with contextlib.redirect_stderr(stderr_capture):
-                        syncbuf,
+                        syncbuf = SyncBuffer(
-                        force_sync=opt.force_sync,
+                            project.manifest.manifestProject.config,
-                        force_checkout=opt.force_checkout,
+                            detach_head=opt.detach_head,
-                        force_rebase=opt.rebase,
-                        errors=local_half_errors,
-                        verbose=opt.verbose,
-                    )
-                    checkout_success = syncbuf.Finish()
-                    if local_half_errors:
-                        checkout_error = SyncError(
-                            aggregate_errors=local_half_errors
                         )
-            except KeyboardInterrupt:
+                        local_half_errors = []
-                logger.error(
+                        project.Sync_LocalHalf(
-                    "Keyboard interrupt while processing %s", project.name
+                            syncbuf,
-                )
+                            force_sync=opt.force_sync,
-            except GitError as e:
+                            force_checkout=opt.force_checkout,
-                checkout_error = e
+                            force_rebase=opt.rebase,
-                logger.error(
+                            errors=local_half_errors,
-                    "error.GitError: Cannot checkout %s: %s", project.name, e
+                            verbose=opt.verbose,
-                )
+                        )
-            except Exception as e:
+                        checkout_success = syncbuf.Finish()
-                checkout_error = e
+                        if local_half_errors:
-                logger.error(
+                            checkout_error = SyncError(
-                    "error: Cannot checkout %s: %s: %s",
+                                aggregate_errors=local_half_errors
-                    project.name,
+                            )
-                    type(e).__name__,
+                except KeyboardInterrupt:
-                    e,
+                    logger.error(
-                )
+                        "Keyboard interrupt while processing %s", project.name
-            finally:
+                    )
-                checkout_finish = time.time()
+                except GitError as e:
-                checkout_stderr = stderr_capture.getvalue()
+                    checkout_error = e
-        elif fetch_success:
+                    logger.error(
-            checkout_success = True
+                        "error.GitError: Cannot checkout %s: %s",
+                        project.name,
+                        e,
+                    )
+                except Exception as e:
+                    checkout_error = e
+                    logger.error(
+                        "error: Cannot checkout %s: %s: %s",
+                        project.name,
+                        type(e).__name__,
+                        e,
+                    )
+                finally:
+                    checkout_finish = time.time()
+                    checkout_stderr = stderr_capture.getvalue()
 
         # Consolidate all captured output.
         captured_parts = []

tests/test_subcmds_sync.py

@@ -309,6 +309,7 @@ class FakeProject:
         self.relpath = relpath
         self.name = name or relpath
         self.objdir = objdir or relpath
+        self.worktree = relpath
 
         self.use_git_worktrees = False
         self.UseAlternates = False
@@ -836,6 +837,25 @@ class InterleavedSyncTest(unittest.TestCase):
         project.Sync_NetworkHalf.assert_called_once()
         project.Sync_LocalHalf.assert_not_called()
 
+    def test_worker_no_worktree(self):
+        """Test interleaved sync does not checkout with no worktree."""
+        opt = self._get_opts()
+        project = self.projA
+        project.worktree = None
+        project.Sync_NetworkHalf = mock.Mock(
+            return_value=SyncNetworkHalfResult(error=None, remote_fetched=True)
+        )
+        project.Sync_LocalHalf = mock.Mock()
+        self.mock_context["projects"] = [project]
+
+        result_obj = self.cmd._SyncProjectList(opt, [0])
+        result = result_obj.results[0]
+
+        self.assertTrue(result.fetch_success)
+        self.assertTrue(result.checkout_success)
+        project.Sync_NetworkHalf.assert_called_once()
+        project.Sync_LocalHalf.assert_not_called()
+
     def test_worker_fetch_fails_exception(self):
         """Test _SyncProjectList with an exception during fetch."""
         opt = self._get_opts()