test_connect_slicer_3602.py 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163
  1. """The Connect slicer page's data: what a user enters in their slicer (#3602).
  2. A user without Settings access gets their personal access code, the virtual
  3. printers they may send to and the CA certificate. Which virtual printers is the
  4. sign-in's own rule, so the page never lists one the sign-in would refuse.
  5. """
  6. import pytest
  7. from backend.app.models.settings import Settings
  8. from backend.app.models.virtual_printer import VirtualPrinter
  9. from backend.app.services.virtual_printer.user_codes import user_for_code
  10. from backend.tests.integration.test_vp_user_codes import QUEUE, UPLOAD, _auth, _login, _user
  11. pytestmark = [pytest.mark.asyncio, pytest.mark.integration]
  12. URL = "/api/v1/virtual-printers/connect-info"
  13. async def _signed_in(async_client, db, permissions, **kwargs) -> dict:
  14. db.add(Settings(key="advanced_auth_enabled", value="false"))
  15. await _auth(db)
  16. await _user(db, permissions, **kwargs)
  17. return await _login(async_client)
  18. def _vp(name, mode, *, enabled=True, target=None, suffix="391800001", **kwargs) -> VirtualPrinter:
  19. return VirtualPrinter(
  20. name=name,
  21. mode=mode,
  22. enabled=enabled,
  23. target_printer_id=target,
  24. serial_suffix=suffix,
  25. access_code="87654321",
  26. **kwargs,
  27. )
  28. async def test_lists_what_the_user_may_send_to(async_client, db_session):
  29. headers = await _signed_in(async_client, db_session, UPLOAD)
  30. db_session.add_all(
  31. [
  32. _vp("Files", "library", suffix="391800001", bind_ip="10.0.0.5"),
  33. _vp("Review", "review", suffix="391800002", bind_ip="10.0.0.6", remote_interface_ip="100.64.0.9"),
  34. _vp("Queue", "queue", suffix="391800003"), # needs queue:create too
  35. _vp("Proxy", "proxy", suffix="391800004"), # personal codes never work there
  36. _vp("Off", "library", enabled=False, suffix="391800005"),
  37. ]
  38. )
  39. await db_session.commit()
  40. response = await async_client.get(URL, headers=headers)
  41. assert response.status_code == 200, response.text
  42. body = response.json()
  43. assert body["auth_enabled"] is True
  44. printers = {p["name"]: p for p in body["printers"]}
  45. assert set(printers) == {"Files", "Review"}
  46. assert printers["Files"]["address"] == "10.0.0.5"
  47. # The address the virtual printer advertises, as its certificate names it.
  48. assert printers["Review"]["address"] == "100.64.0.9"
  49. assert printers["Files"]["mode"] == "library"
  50. assert printers["Files"]["serial"].endswith("391800001")
  51. assert printers["Files"]["target_printer_name"] is None
  52. assert "87654321" not in response.text # never a virtual printer's own code
  53. async def test_a_target_printer_must_be_readable_and_in_scope(async_client, db_session, printer_factory):
  54. mine = await printer_factory(name="Mine")
  55. other = await printer_factory(name="Other")
  56. headers = await _signed_in(async_client, db_session, [*QUEUE, "printers:read"], restrict_to=[mine.id])
  57. db_session.add_all(
  58. [
  59. _vp("To mine", "queue", target=mine.id, suffix="391800001"),
  60. _vp("To other", "queue", target=other.id, suffix="391800002"),
  61. _vp("Any X1C", "queue", suffix="391800003"),
  62. ]
  63. )
  64. await db_session.commit()
  65. printers = {p["name"]: p for p in (await async_client.get(URL, headers=headers)).json()["printers"]}
  66. assert set(printers) == {"To mine", "Any X1C"}
  67. assert printers["To mine"]["target_printer_name"] == "Mine"
  68. assert printers["Any X1C"]["target_printer_name"] is None
  69. @pytest.mark.parametrize(
  70. "permissions",
  71. [UPLOAD, QUEUE, [*QUEUE, "printers:read"], ["library:read_own"]],
  72. )
  73. async def test_the_page_and_the_sign_in_agree(async_client, db_session, printer_factory, permissions):
  74. printer = await printer_factory(name="P")
  75. headers = await _signed_in(async_client, db_session, permissions)
  76. cases = [
  77. ("library", None),
  78. ("review", None),
  79. ("queue", None),
  80. ("queue", printer.id),
  81. ("library", printer.id),
  82. ("proxy", printer.id),
  83. ]
  84. for index, (mode, target) in enumerate(cases):
  85. db_session.add(_vp(f"vp{index}", mode, target=target, suffix=f"39180000{index}"))
  86. await db_session.commit()
  87. listed = {p["name"] for p in (await async_client.get(URL, headers=headers)).json()["printers"]}
  88. for index, (mode, target) in enumerate(cases):
  89. signs_in = await user_for_code(db_session, "11112222", mode=mode, target_printer_id=target) is not None
  90. assert (f"vp{index}" in listed) is signs_in, (mode, target)
  91. async def test_with_auth_off_there_are_no_personal_codes(async_client, db_session):
  92. await _auth(db_session, on=False)
  93. db_session.add(Settings(key="virtual_printer_connect_instructions", value="Connect to the VPN first."))
  94. db_session.add(_vp("Files", "library"))
  95. await db_session.commit()
  96. body = (await async_client.get(URL)).json()
  97. assert body == {"auth_enabled": False, "instructions": "Connect to the VPN first.", "printers": []}
  98. async def test_the_admins_instructions_reach_every_user(async_client, db_session):
  99. headers = await _signed_in(async_client, db_session, ["library:read_own"])
  100. db_session.add(Settings(key="virtual_printer_connect_instructions", value="**VPN** first"))
  101. await db_session.commit()
  102. body = (await async_client.get(URL, headers=headers)).json()
  103. assert body["instructions"] == "**VPN** first"
  104. assert body["printers"] == []
  105. async def test_refused_without_signing_in_and_for_an_api_key(async_client, db_session):
  106. from backend.app.core.auth import generate_api_key
  107. from backend.app.models.api_key import APIKey
  108. await _auth(db_session)
  109. full_key, key_hash, key_prefix = generate_api_key()
  110. db_session.add(APIKey(name="k", key_hash=key_hash, key_prefix=key_prefix, can_read_status=True))
  111. await db_session.commit()
  112. assert (await async_client.get(URL)).status_code == 401
  113. assert (await async_client.get(URL, headers={"X-API-Key": full_key})).status_code == 403
  114. class TestTheCaCertificateIsForEverySignedInUser:
  115. @pytest.fixture(autouse=True)
  116. def _own_ca_dir(self, monkeypatch, tmp_path):
  117. from backend.app.services.virtual_printer import virtual_printer_manager
  118. monkeypatch.setattr(virtual_printer_manager, "_base_dir", tmp_path)
  119. @pytest.mark.parametrize(
  120. "path", ["/api/v1/virtual-printers/ca-certificate", "/api/v1/virtual-printers/ca-certificate/installer/unix"]
  121. )
  122. async def test_without_settings_access(self, async_client, db_session, path):
  123. headers = await _signed_in(async_client, db_session, ["library:read_own"])
  124. assert (await async_client.get(path, headers=headers)).status_code == 200
  125. assert (await async_client.get(path)).status_code == 401