RemoteRF 2.1.1__tar.gz → 2.1.9__tar.gz

{remoterf-2.1.1/src/remoterf.egg-info → remoterf-2.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.1.1
+Version: 2.1.9
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author-email: Ethan Ge <ethoGalaxy@gmail.com>
 License-Expression: GPL-3.0-or-later

{remoterf-2.1.1 → remoterf-2.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoterf"
-version = "2.1.1"
+version = "2.1.9"
 description = "A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{remoterf-2.1.1 → remoterf-2.1.9}/src/remoteRF/core/app.py

@@ -230,8 +230,8 @@ def _account_command(command):
             # out of quota); there is no token coming. Straight on to login.
             return False
         printf("Verify your email", (Sty.BOLD, Sty.BLUE))
-        printf("  Paste the token from the verification email.", Sty.GRAY)
-        account.backend.verify(_ask('Verification token', hidden=True))
+        printf("  Enter the 6-digit code from the verification email.", Sty.GRAY)
+        account.backend.verify(account.username or account.email, _ask('Verification code').strip())
         printf('Email verified. You can now log in.', (Sty.BOLD, Sty.GREEN))
         return False
     if command in ('forgot-password', 'reset-password'):
@@ -349,7 +349,8 @@ def commands():
     printf("'cancelres' ", Sty.MAGENTA, "     : ", Sty.GRAY, "Cancel a reservation", Sty.DEFAULT)
     printf("'getres' ", Sty.MAGENTA, "        : ", Sty.GRAY, "View all reservations", Sty.DEFAULT)
     printf("'myres' ", Sty.MAGENTA, "         : ", Sty.GRAY, "View my reservations", Sty.DEFAULT)
-    printf("'perms' ", Sty.MAGENTA, "         : ", Sty.GRAY, "View permissions", Sty.DEFAULT)
+    if not account.is_https_home:
+        printf("'perms' ", Sty.MAGENTA, "         : ", Sty.GRAY, "View permissions", Sty.DEFAULT)
     printf("'enroll' ", Sty.MAGENTA, "        : ", Sty.GRAY, "Enroll with an enrollment code", Sty.DEFAULT)
     printf("'logout' ", Sty.MAGENTA, "        : ", Sty.GRAY, "Log out and forget the stored login", Sty.DEFAULT)
     printf("'status' ", Sty.MAGENTA, "        : ", Sty.GRAY, "Connection and the path device calls use", Sty.DEFAULT)
@@ -538,6 +539,8 @@ def _federated_reserve_slot(device_id, chosen_day, chosen_slot, slot_start_str,
     printf("Reservation successful for ", (Sty.BOLD, Sty.GREEN), f"{chosen_day.strftime('%Y-%m-%d')} {slot_start_str}-{slot_end_str}.", Sty.CYAN)
     printf("Your device handle -> ", Sty.BOLD, f"{handle}", (Sty.BOLD, Sty.GREEN))
     printf("Use it where a token goes, e.g. adi.Pluto(\"" + handle + "\"); it works while you are logged in to this home.", Sty.DEFAULT)
+    printf("The first call can take ~20 s while the radio powers on.", Sty.GRAY)
+    account.install_reserved_driver(handle, device_id)
 
 
 def _federated_reserve():
@@ -581,7 +584,8 @@ def _federated_reserve():
         )
         return
     _pick_slot_and_reserve(dev["device_id"], dev["display_name"], dev["block_min"], _federated_reservations_for_range, _federated_reserve_slot,
-                           device_label=f"{dev['display_name']} @{dev['deployment_name']}")
+                           device_label=f"{dev['display_name']} @{dev['deployment_name']}",
+                           max_days=-(-int(dev.get("max_horizon_sec") or 0) // 86400) or None)
 
 
 def reservations():
@@ -841,6 +845,7 @@ def reserve():
         if token != '':
             printf(f"Reservation successful. Your Token -> ", Sty.BOLD, f"{token}", Sty.BG_GREEN)
             printf(f"Please keep this token safe, as it is not saved on the server and cannot be retrieved again. If you lose it, cancel your reservation and make a new one. ", Sty.DEFAULT)
+            account.install_reserved_driver(token, rows[int(pick) - 1]["id"])
     except Exception as e:
         printf(f"Error: {e}", Sty.BRIGHT_RED)
 
@@ -985,7 +990,7 @@ def perms():
         printf("Accessible Devices: ", (Sty.BOLD, Sty.BLUE), f"{devices}", Sty.MAGENTA)
 
         # Build per-device caps and group identical limits together
-        buckets: dict[tuple[int, int], list[int]] = {}  # (max_r, max_t_sec) -> [dev_ids]
+        buckets: dict[tuple[int, int, int], list[int]] = {}  # (max_r, max_t_sec, horizon_sec) -> [dev_ids]
         for d in devices:
             try:
                 did = int(d)
@@ -994,7 +999,8 @@ def perms():
             c = _cap_for(did)
             max_t = int(c.get("max_reservation_time_sec", 0) or 0)
             max_r = int(c.get("max_reservations", 0) or 0)
-            buckets.setdefault((max_r, max_t), []).append(did)
+            max_h = int(c.get("max_horizon_sec", 0) or 0)
+            buckets.setdefault((max_r, max_t, max_h), []).append(did)
 
         if not buckets:
             print("Limits per device: (none)")
@@ -1003,16 +1009,17 @@ def perms():
 
         # If everything shares the same limits, print once
         if len(buckets) == 1:
-            (max_r, max_t), _devs = next(iter(buckets.items()))
+            (max_r, max_t, max_h), _devs = next(iter(buckets.items()))
             printf("Permissions:", (Sty.BOLD, Sty.BLUE))
             printf("  Max Reservations: ", Sty.GRAY, f"{max_r}", Sty.CYAN)
             printf("  Reservation Duration (min): ", Sty.GRAY, f"{max_t // 60}", Sty.CYAN)
+            printf("  Days Ahead: ", Sty.GRAY, f"{max_h / 86400:g}" if max_h else "no limit", Sty.CYAN)
             render_remote_permissions()
             return
 
         # Otherwise print grouped limits
         printf("Permissions per device (grouped):", (Sty.BOLD, Sty.BLUE))
-        for (max_r, max_t), devs in sorted(buckets.items(), key=lambda kv: (kv[0][0], kv[0][1], kv[1])):
+        for (max_r, max_t, max_h), devs in sorted(buckets.items(), key=lambda kv: (kv[0][0], kv[0][1], kv[0][2], kv[1])):
             devs = sorted(devs)
 
             # compress ranges like 0-3,5,7-9
@@ -1031,7 +1038,7 @@ def perms():
                 ranges.append(f"{start}-{prev}" if start != prev else f"{start}")
 
             dev_str = ",".join(ranges)
-            printf("  devices[", Sty.GRAY, f"{dev_str}", Sty.MAGENTA, "]: ", Sty.GRAY, f"max_reservations={max_r}, max_time_min={max_t // 60}", Sty.CYAN)
+            printf("  devices[", Sty.GRAY, f"{dev_str}", Sty.MAGENTA, "]: ", Sty.GRAY, f"max_reservations={max_r}, max_time_min={max_t // 60}, days_ahead={f'{max_h / 86400:g}' if max_h else 'no limit'}", Sty.CYAN)
 
         render_remote_permissions()
 
@@ -1278,6 +1285,7 @@ def interactive_reserve_next_days(block_minutes=60):
             printf("Reservation successful on device ", (Sty.BOLD, Sty.GREEN), f"{chosen_device_id}", Sty.MAGENTA, " for ", Sty.DEFAULT, f"{chosen_day.strftime('%Y-%m-%d')} {slot_start_str}-{slot_end_str}.", Sty.CYAN)
             printf("Your Token -> ", Sty.BOLD, f"{token}", (Sty.BOLD, Sty.GREEN))
             printf("Please keep this token safe, as it is not saved on the server and cannot be retrieved again. If you lose it, cancel your reservation and make a new one.", Sty.DEFAULT)
+            account.install_reserved_driver(token, int(chosen_device_id))
         
     except Exception as e:
         print(f"Error: {e}")
@@ -1306,16 +1314,18 @@ def _auto_block_minutes(max_t_sec: int) -> int:
             break
     return best
 
-def _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, reservations_for_range, do_reserve, *, device_label=None):
+def _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, reservations_for_range, do_reserve, *, device_label=None, max_days=None):
     """Shared `resdev` slot picker: days -> free slots -> pick -> confirm -> reserve.
     Native and federated homes differ only in how reservations are fetched and
-    how the reservation is made (token vs. HOME handle)."""
+    how the reservation is made (token vs. HOME handle). `max_days` is the
+    group's reservation horizon; the server refuses starts beyond it anyway."""
     device_label = chosen_device_id if device_label is None else device_label
-    num_days_s = session.prompt(stylize("Enter the number of days to check for available reservations (starting today): ", (Sty.BOLD, Sty.GREEN))).strip()
+    limit = f" (up to {max_days})" if max_days else ""
+    num_days_s = session.prompt(stylize(f"Enter the number of days to check for available reservations (starting today){limit}: ", (Sty.BOLD, Sty.GREEN))).strip()
     try:
         num_days = int(num_days_s)
-        if num_days <= 0:
-            print("Invalid number of days.")
+        if num_days <= 0 or (max_days and num_days > max_days):
+            print("Invalid number of days." if num_days <= 0 else f"Your group may reserve at most {max_days} days ahead.")
             return
     except ValueError:
         print("Invalid input. Please enter a number.")
@@ -1419,6 +1429,7 @@ def _native_reserve_slot(chosen_device_id, chosen_day, chosen_slot, slot_start_s
         printf("Reservation successful on device ", (Sty.BOLD, Sty.GREEN), f"{chosen_device_id}", Sty.MAGENTA, " for ", Sty.DEFAULT, f"{chosen_day.strftime('%Y-%m-%d')} {slot_start_str}-{slot_end_str}.", Sty.CYAN)
         printf("Your Token -> ", Sty.BOLD, f"{token}", (Sty.BOLD, Sty.GREEN))
         printf("Please keep this token safe, as it is not saved on the server and cannot be retrieved again. If you lose it, cancel your reservation and make a new one.", Sty.DEFAULT)
+        account.install_reserved_driver(token, int(chosen_device_id))
 
 
 def interactive_reserve_next_days_auto():
@@ -1492,7 +1503,10 @@ def interactive_reserve_next_days_auto():
         sorted_device_ids = sorted(dev_resp.results.keys(), key=int)  # strings
 
         if allowed_dev_ids is not None:
-            sorted_device_ids = [d for d in sorted_device_ids if int(d) in allowed_dev_ids]
+            # A partner lab's device is listed only when this account is enrolled
+            # there; it needs no local group (and has no local caps: 30 min blocks).
+            sorted_device_ids = [d for d in sorted_device_ids
+                                 if int(d) in allowed_dev_ids or _PARTNER_LABEL.match(str(unmap_arg(dev_resp.results[d])))]
 
         if not sorted_device_ids:
             printf("No devices available for your permission level.", Sty.WARNING)
@@ -1501,6 +1515,7 @@ def interactive_reserve_next_days_auto():
         printf("Devices:", Sty.BOLD)
         block_by_dev: dict[str, int] = {}
         max_by_dev: dict[str, int] = {}
+        days_by_dev: dict[str, int] = {}
 
         for idx, dev_id in enumerate(sorted_device_ids):
             dev_name = unmap_arg(dev_resp.results[dev_id])
@@ -1510,6 +1525,7 @@ def interactive_reserve_next_days_auto():
                 c = _cap_for(int(dev_id))
                 try:
                     max_t_sec = int(c.get("max_reservation_time_sec", 0) or 0)
+                    days_by_dev[str(dev_id)] = -(-int(c.get("max_horizon_sec", 0) or 0) // 86400)
                 except Exception:
                     max_t_sec = 0
             elif perm_level == "Power User" and power_user_max_t_sec is not None:
@@ -1562,7 +1578,8 @@ def interactive_reserve_next_days_auto():
             )
             return
 
-        _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, fetch_reservations_for_range, _native_reserve_slot)
+        _pick_slot_and_reserve(chosen_device_id, chosen_device_name, block_minutes, fetch_reservations_for_range, _native_reserve_slot,
+                               max_days=days_by_dev.get(chosen_device_id) or None)
 
     except Exception as e:
         print(f"Error: {e}")
@@ -1635,7 +1652,7 @@ def run(backend=None, *, register=False, enrollment_code=None, server_label=None
                     devices()
                 elif inpu == "help" or inpu == "h":
                     commands()
-                elif inpu == "perms":
+                elif inpu == "perms" and not account.is_https_home:
                     perms()
                 elif inpu == "enroll":
                     enroll()
@@ -1666,7 +1683,7 @@ def run(backend=None, *, register=False, enrollment_code=None, server_label=None
                     reserve()
                 elif account.is_admin and inpu.strip().startswith("admin"):
                     handle_admin_command(inpu)
-                else:
+                elif inpu.strip():
                     print(f"Unknown command: {inpu}")
             except AccountBackendError as exc:
                 label = f" [{exc.provenance}]" if exc.provenance else ""

{remoterf-2.1.1 → remoterf-2.1.9}/src/remoteRF/core/direct_path.py

@@ -124,7 +124,7 @@ def quiet_aioice_errors(loop) -> None:
         where = repr(context.get("handle", "")) + str(context.get("message", ""))
         if isinstance(exc, (AttributeError, OSError)) and "Transaction.__retry" in where:
             return
-        if isinstance(exc, ConnectionError) and "exception was never retrieved" in where:
+        if isinstance(exc, ConnectionError) and ("exception was never retrieved" in where or "shielded future" in where):
             return
         default(context)
 

{remoterf-2.1.1 → remoterf-2.1.9}/src/remoteRF/core/grpc_acc.py

@@ -20,6 +20,12 @@ from ..common.utils import *
 
 import datetime
 
+def _busy(label):
+    """A spinner while the home asks its labs: a slow lab is a wait, not a hang."""
+    from ..remoterf_cli import _working
+    return _working(label)
+
+
 class RemoteRFAccount:
     def __init__(self, username:str=None, password:str=None, email:str=None, *, backend=None):
         self.username = username
@@ -93,51 +99,58 @@ class RemoteRFAccount:
     
     def reserve_device(self, device_id, start_time:datetime, end_time:datetime):
         if self.is_https_home:
-            reservation = self.backend.reserve(device_id, int(start_time.timestamp()), int(end_time.timestamp()))
-            try:
-                from ..drivers.dynamic_device import install_driver
-                install_driver(device_id=reservation['device_id'])
-            except Exception as e:
-                print(f"Warning: could not install driver for device {reservation['device_id']}: {e}")
+            with _busy("Reserving…"):
+                reservation = self.backend.reserve(device_id, int(start_time.timestamp()), int(end_time.timestamp()))
             # The HOME reference is the driver handle: adi.Pluto("<deployment>:<id>")
             return reservation['device_id']
         username, credential_secret = self._rpc_credentials()
-        response = self._call(function_name="ACC:reserve_device", args={"un":map_arg(username), "pw":map_arg(credential_secret), "dd":map_arg(device_id), "st":map_arg(int(start_time.timestamp())), "et":map_arg(int(end_time.timestamp()))})
+        with _busy("Reserving…"):
+            response = self._call(function_name="ACC:reserve_device", args={"un":map_arg(username), "pw":map_arg(credential_secret), "dd":map_arg(device_id), "st":map_arg(int(start_time.timestamp())), "et":map_arg(int(end_time.timestamp()))})
 
         if 'ace' in response.results:
             raise Exception(f'{unmap_arg(response.results["ace"])}')
         elif 'Token' in response.results:
-            token = unmap_arg(response.results["Token"])
-            try:
-                from ..drivers.dynamic_device import install_driver
-                install_driver(token=token, device_id=device_id)
-            except Exception as e:
-                print(f"Warning: could not install driver for device {device_id}: {e}")
-            return token
+            return unmap_arg(response.results["Token"])
+
+    def install_reserved_driver(self, handle, device_id):
+        """Separate from reserve_device: the token is shown before this network
+        step runs, so a failed or stuck driver fetch cannot lose it."""
+        try:
+            from ..drivers.dynamic_device import install_driver
+            if self.is_https_home:
+                install_driver(device_id=handle)
+            else:
+                install_driver(token=handle, device_id=device_id)
+        except Exception as e:
+            print(f"Warning: could not install driver for device {device_id}: {e}")
             
     def get_reservations(self):
-        if self.is_https_home:
-            return self.backend.reservations()
-        username, credential_secret = self._rpc_credentials()
-        return self._call(function_name='ACC:get_res', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
+        with _busy("Asking the labs for reservations…"):
+            if self.is_https_home:
+                return self.backend.reservations()
+            username, credential_secret = self._rpc_credentials()
+            return self._call(function_name='ACC:get_res', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
     
     def get_devices(self):
-        if self.is_https_home:
-            return self.backend.devices()
-        username, credential_secret = self._rpc_credentials()
-        return self._call(function_name='ACC:get_dev', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
+        with _busy("Asking the labs for devices…"):
+            if self.is_https_home:
+                return self.backend.devices()
+            username, credential_secret = self._rpc_credentials()
+            return self._call(function_name='ACC:get_dev', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
     
     def cancel_reservation(self, res_id):
-        if self.is_https_home:
-            return self.backend.cancel(res_id)
-        username, credential_secret = self._rpc_credentials()
-        return self._call(function_name='ACC:cancel_res', args={"un":map_arg(username), "pw":map_arg(credential_secret), "res_id":map_arg(res_id)})
+        with _busy("Cancelling…"):
+            if self.is_https_home:
+                return self.backend.cancel(res_id)
+            username, credential_secret = self._rpc_credentials()
+            return self._call(function_name='ACC:cancel_res', args={"un":map_arg(username), "pw":map_arg(credential_secret), "res_id":map_arg(res_id)})
     
     def get_perms(self):
-        if self.is_https_home:
-            return self.backend.permissions()
-        username, credential_secret = self._rpc_credentials()
-        return self._call(function_name='ACC:get_perms', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
+        with _busy("Asking the labs for permissions…"):
+            if self.is_https_home:
+                return self.backend.permissions()
+            username, credential_secret = self._rpc_credentials()
+            return self._call(function_name='ACC:get_perms', args={"un":map_arg(username), "pw":map_arg(credential_secret)})
     
     def logout(self):
         """Revoke the stored session on the deployment (best effort)."""

{remoterf-2.1.1 → remoterf-2.1.9}/src/remoteRF/deployment/backend.py

@@ -111,10 +111,10 @@ class HttpsJsonAccountBackend(DeploymentAccountBackend):
             data={"username": name, "email": email, "password": password},
         )
 
-    def verify(self, token):
+    def verify(self, login, code):
         self._operation("ACC:verify_email")
         return self.transport.request(
-            "POST", self.base + "/verify-email", data={"token": token}
+            "POST", self.base + "/verify-email", data={"login": login, "code": code}
         )
 
     def _validate_session(self, value, expected_subject=None):

{remoterf-2.1.1 → remoterf-2.1.9}/src/remoteRF/deployment/http.py

@@ -73,7 +73,7 @@ class JsonTransport:
                 timeout=timeout,
             ) as response:
                 raw = bytearray()
-                for chunk in response.iter_bytes(chunk_size=1):
+                for chunk in response.iter_bytes(chunk_size=65536):
                     if time.monotonic() >= deadline:
                         raise AccountBackendError("Account operation deadline exceeded")
                     raw.extend(chunk)

{remoterf-2.1.1 → remoterf-2.1.9}/src/remoteRF/remoterf_cli.py

@@ -332,13 +332,15 @@ def _register() -> int:
         return 1
     remember_tos_agreement()
     try:
-        entered = input('Enrollment code: ').strip()
+        entered = input('Enrollment code (Enter for a RemoteRF Global account): ').strip()
     except (EOFError, KeyboardInterrupt):
         print()
         return 1
     if not entered:
-        printf('An enrollment code is required. Ask your lab for one.', Sty.WARNING)
-        return 2
+        # No lab yet: the account lives on Global. A lab's invite can still
+        # be redeemed later, from the shell, with `enroll <invite>`.
+        printf('Registering a RemoteRF Global account. Join a lab any time with: enroll <lab invite>', Sty.GRAY)
+        return _use_global(register=True, show_banner=False)
     try:
         host, code = homes.parse_code(entered)
     except ValidationError as exc:
@@ -378,8 +380,10 @@ def _login(target: str | None) -> int:
         elif saved:
             return _print_pick_a_target()
         else:
-            # Nothing has been saved: fall through to whatever the client was
-            # configured with directly, exactly as before homes existed.
+            # Nothing saved. A legacy address in .env still logs in there;
+            # a fresh install has nothing to log in to, so `-l` is `-r`.
+            if not _ensure_config_present()[0]:
+                return _register()
             return _account_shell(register=False)
     if target == 'global':
         if not homes.has_global_account():

{remoterf-2.1.1 → remoterf-2.1.9/src/remoterf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.1.1
+Version: 2.1.9
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author-email: Ethan Ge <ethoGalaxy@gmail.com>
 License-Expression: GPL-3.0-or-later

{remoterf-2.1.1 → remoterf-2.1.9}/src/remoterf.egg-info/SOURCES.txt

@@ -69,6 +69,7 @@ src/remoterf.egg-info/entry_points.txt
 src/remoterf.egg-info/requires.txt
 src/remoterf.egg-info/top_level.txt
 tests/test_banner.py
+tests/test_cli_login_fresh.py
 tests/test_config_address.py
 tests/test_deployment_accounts.py
 tests/test_direct_path_fixed.py

remoterf-2.1.9/tests/test_cli_login_fresh.py

@@ -0,0 +1,54 @@
+"""`remoterf -l` on a fresh install is `remoterf -r`; a configured client logs in."""
+
+import os
+import tempfile
+from unittest import mock
+
+
+def _fresh_home():
+    tmp = tempfile.TemporaryDirectory()
+    env = {k: v for k, v in os.environ.items() if not k.startswith("REMOTERF_")}
+    env["HOME"] = tmp.name
+    return tmp, mock.patch.dict(os.environ, env, clear=True)
+
+
+def test_login_on_a_fresh_install_registers():
+    from remoteRF import remoterf_cli
+
+    tmp, env = _fresh_home()
+    with tmp, env, \
+            mock.patch("remoteRF.config.config.require_tos_for_login", return_value=True), \
+            mock.patch.object(remoterf_cli, "_register", return_value=0) as register, \
+            mock.patch.object(remoterf_cli, "_account_shell") as shell:
+        assert remoterf_cli._login(None) == 0
+    register.assert_called_once_with()
+    shell.assert_not_called()
+
+
+def test_login_with_a_legacy_address_still_logs_in_there():
+    from remoteRF import remoterf_cli
+
+    tmp, env = _fresh_home()
+    with tmp, env, \
+            mock.patch("remoteRF.config.config.require_tos_for_login", return_value=True), \
+            mock.patch.object(remoterf_cli, "_ensure_config_present", return_value=(True, "")), \
+            mock.patch.object(remoterf_cli, "_register") as register, \
+            mock.patch.object(remoterf_cli, "_account_shell", return_value=0) as shell:
+        assert remoterf_cli._login(None) == 0
+    shell.assert_called_once_with(register=False)
+    register.assert_not_called()
+
+
+def test_register_without_a_code_makes_a_global_account(monkeypatch):
+    from remoteRF import remoterf_cli
+
+    monkeypatch.setattr("builtins.input", lambda prompt="": "")
+    with mock.patch("remoteRF.config.config._confirm_tos", return_value=True), \
+            mock.patch("remoteRF.config.config.forget_tos_agreement"), \
+            mock.patch("remoteRF.config.config.remember_tos_agreement"), \
+            mock.patch.object(remoterf_cli, "print_client_banner"), \
+            mock.patch.object(remoterf_cli, "_use_global", return_value=0) as use_global, \
+            mock.patch.object(remoterf_cli, "_account_shell") as shell:
+        assert remoterf_cli._register() == 0
+    use_global.assert_called_once_with(register=True, show_banner=False)
+    shell.assert_not_called()

{remoterf-2.1.1 → remoterf-2.1.9}/tests/test_homes.py

@@ -314,12 +314,13 @@ def test_register_with_a_code_lands_in_the_home_shell(monkeypatch, reachable):
     assert homes.last_target() == {"kind": "home", "name": "ucla"}
 
 
-def test_a_blank_code_is_refused_and_global_has_its_own_spelling(monkeypatch):
+def test_a_blank_code_registers_on_global_and_global_has_its_own_spelling(monkeypatch):
     answers = iter(["y", ""])
     monkeypatch.setattr("builtins.input", lambda *_: next(answers, ""))
     used_global = mock.Mock(return_value=0)
-    assert run_cli(["-r"], monkeypatch, _use_global=used_global) == 2
-    used_global.assert_not_called()
+    assert run_cli(["-r"], monkeypatch, _use_global=used_global) == 0
+    used_global.assert_called_once_with(register=True, show_banner=False)  # no lab: the account lives on Global
+    used_global.reset_mock()
     assert run_cli(["-r", "global"], monkeypatch, _use_global=used_global) == 0
     used_global.assert_called_once_with(register=True)
 
@@ -337,7 +338,8 @@ def test_declining_the_terms_stops_registration_before_any_code(monkeypatch):
     answers = iter(["y"])
     monkeypatch.setattr("builtins.input", lambda prompt="": next(answers))
     shell = mock.Mock(return_value=0)
-    assert run_cli(["-l"], monkeypatch, _account_shell=shell) == 0
+    # A configured client (a legacy address) logs in; unconfigured, `-l` would register.
+    assert run_cli(["-l"], monkeypatch, _account_shell=shell, _ensure_config_present=lambda: (True, "")) == 0
     assert cfg.tos_agreed()
     monkeypatch.setattr("builtins.input", lambda prompt="": (_ for _ in ()).throw(AssertionError(prompt)))
     assert run_cli(["-l"], monkeypatch, _account_shell=shell) == 0  # remembered: no prompt

{remoterf-2.1.1 → remoterf-2.1.9}/tests/test_remoterf_cli.py

@@ -5,30 +5,7 @@ from remoteRF import remoterf_cli
 
 
 class RemoteRFCliTests(unittest.TestCase):
-    @mock.patch.object(remoterf_cli, "printf")
-    @mock.patch.object(remoterf_cli, "print_client_banner")
-    @mock.patch.object(
-        remoterf_cli,
-        "_ensure_config_present",
-        return_value=(False, "not configured"),
-    )
-    @mock.patch.object(remoterf_cli, "_installed_version", return_value="2.0.9")
-    @mock.patch.object(remoterf_cli.sys, "argv", ["remoterf", "-l"])
-    def test_unconfigured_login_shows_na_banner_and_configure_message(
-        self,
-        _version,
-        _ensure_config,
-        print_banner,
-        printf,
-    ):
-        self.assertEqual(remoterf_cli.main(), 2)
-        print_banner.assert_called_once_with("2.0.9", server="")
-        self.assertTrue(
-            any(
-                call.args and call.args[0] == "Please configure remoterf properly first."
-                for call in printf.call_args_list
-            )
-        )
+    # `-l` on an unconfigured client registers instead: tests/test_cli_login_fresh.py
 
     @mock.patch.object(remoterf_cli, "_print_server_unavailable")
     @mock.patch.object(remoterf_cli, "_connected_server", return_value=None)