From 064516efa3c5ca27a97abbdac1901a9d8ad17753 Mon Sep 17 00:00:00 2001 From: muzakon Date: Tue, 17 Nov 2026 16:07:20 +0300 Subject: [PATCH 1/4] Export named constants for fixed API values Signal, SuspectLevel, Confidence, EventState, Environment, AttestationState, AttestationStatus, AttestSkippedReason, VerifyReason and WebhookEventType are str enums whose members equal their raw values. Model fields stay typed str so an unknown value still parses. VerifyReason is now an enum class instead of a Literal alias, and SIGNAL_NAMES is built from Signal. --- src/fingerly/__init__.py | 22 ++- src/fingerly/_client.py | 24 ++- src/fingerly/_enums.py | 216 ++++++++++++++++++++++ src/fingerly/_models.py | 130 +++----------- tests/test_enums.py | 349 ++++++++++++++++++++++++++++++++++++ tests/test_events_verify.py | 9 +- 6 files changed, 636 insertions(+), 114 deletions(-) create mode 100644 src/fingerly/_enums.py create mode 100644 tests/test_enums.py diff --git a/src/fingerly/__init__.py b/src/fingerly/__init__.py index e3e7c56..f6d9c6d 100644 --- a/src/fingerly/__init__.py +++ b/src/fingerly/__init__.py @@ -20,6 +20,18 @@ Events, Fingerly, ) +from ._enums import ( + AttestationState, + AttestationStatus, + AttestSkippedReason, + Confidence, + Environment, + EventState, + Signal, + SuspectLevel, + VerifyReason, + WebhookEventType, +) from ._errors import ( FingerlyAPIError, FingerlyConnectionError, @@ -39,7 +51,6 @@ EventDocument, EventPage, EventTrigger, - VerifyReason, VerifyResult, ) from ._proxy import FingerlyProxy, ProxyRequest @@ -51,14 +62,20 @@ "AsyncDeviceCheck", "AsyncEvents", "AsyncFingerly", + "AttestSkippedReason", "Attestation", + "AttestationState", + "AttestationStatus", + "Confidence", "ConsumeResult", "DeviceCheck", "DeviceCheckBits", "DeviceCheckWriteResult", + "Environment", "Event", "EventDocument", "EventPage", + "EventState", "EventTrigger", "Events", "Fingerly", @@ -71,8 +88,11 @@ "FingerlyProxy", "FingerlyTimeoutError", "ProxyRequest", + "Signal", + "SuspectLevel", "VerifyReason", "VerifyResult", + "WebhookEventType", "__version__", "verify_webhook", ] diff --git a/src/fingerly/_client.py b/src/fingerly/_client.py index de7eaf9..f544ae8 100644 --- a/src/fingerly/_client.py +++ b/src/fingerly/_client.py @@ -22,6 +22,7 @@ parse_key, positive_seconds, ) +from ._enums import VerifyReason from ._errors import ( FingerlyAPIError, FingerlyConnectionError, @@ -216,7 +217,7 @@ def verify( payload = self._client._request(path) except FingerlyAPIError as error: if is_not_found(error): - return VerifyResult(ok=False, reason="not_found") + return VerifyResult(ok=False, reason=VerifyReason.NOT_FOUND) raise event, occurred = parse_verified_event(payload) reason = failed_check(event, occurred, _now(), max_age_seconds, tag) @@ -226,12 +227,14 @@ def verify( try: self._client._request(path + "/consume", method="POST") except FingerlyEventAlreadyConsumedError: - return VerifyResult(ok=False, reason="already_consumed", event=event) + return VerifyResult( + ok=False, reason=VerifyReason.ALREADY_CONSUMED, event=event + ) except FingerlyAPIError as error: if is_not_found(error): - return VerifyResult(ok=False, reason="not_found") + return VerifyResult(ok=False, reason=VerifyReason.NOT_FOUND) raise - return VerifyResult(ok=True, reason="", event=event) + return VerifyResult(ok=True, reason=VerifyReason.OK, event=event) def list( self, @@ -250,7 +253,8 @@ def list( page: 1-based page number. limit: Rows per page, at most 200. visitor: Restrict to one exact visitor id. - level: Restrict to ``low``, ``medium`` or ``high``. + level: Restrict to ``low``, ``medium`` or ``high``; a + :class:`SuspectLevel` member works too. Raises: TypeError: If a bound, page or limit is unusable. @@ -293,7 +297,7 @@ async def verify( payload = await self._client._request(path) except FingerlyAPIError as error: if is_not_found(error): - return VerifyResult(ok=False, reason="not_found") + return VerifyResult(ok=False, reason=VerifyReason.NOT_FOUND) raise event, occurred = parse_verified_event(payload) reason = failed_check(event, occurred, _now(), max_age_seconds, tag) @@ -303,12 +307,14 @@ async def verify( try: await self._client._request(path + "/consume", method="POST") except FingerlyEventAlreadyConsumedError: - return VerifyResult(ok=False, reason="already_consumed", event=event) + return VerifyResult( + ok=False, reason=VerifyReason.ALREADY_CONSUMED, event=event + ) except FingerlyAPIError as error: if is_not_found(error): - return VerifyResult(ok=False, reason="not_found") + return VerifyResult(ok=False, reason=VerifyReason.NOT_FOUND) raise - return VerifyResult(ok=True, reason="", event=event) + return VerifyResult(ok=True, reason=VerifyReason.OK, event=event) async def list( self, diff --git a/src/fingerly/_enums.py b/src/fingerly/_enums.py new file mode 100644 index 0000000..9c89a81 --- /dev/null +++ b/src/fingerly/_enums.py @@ -0,0 +1,216 @@ +"""Named constants for the closed string sets the API and webhooks use. + +Every member is a ``str``: it compares equal to, and hashes like, the raw +value, so ``event.suspect_level == SuspectLevel.HIGH`` and +``Signal.TOR in {"tor"}`` both hold. ``str()`` and f-strings give the raw +value on every supported Python, not ``"SuspectLevel.HIGH"``. + +The models keep these fields typed ``str`` and hold the value exactly as the +API sent it, so a value a newer server adds parses instead of raising. Compare +against the members; do not convert with ``SuspectLevel(value)``, which raises +``ValueError`` for a value this release does not know. +""" + +from __future__ import annotations + +from enum import Enum + + +class _StrEnum(str, Enum): + """A ``str`` enum whose text is its value on every Python from 3.9.""" + + def __str__(self) -> str: + return str.__str__(self) + + def __format__(self, format_spec: str) -> str: + return str.__format__(str.__str__(self), format_spec) + + +class Signal(_StrEnum): + """Risk signal and signal-group identifiers. + + ``EventTrigger.signal`` is one of the group names (such as ``VPN``, + ``BOT`` or ``ATTESTATION_FAILED``); archived risk reports also carry the + raw detector names that feed each group (such as ``VPN_TIMEZONE``). + """ + + TOR = "tor" + DATACENTER_PROXY = "datacenter_proxy" + PROXY = "proxy" + DATACENTER_IP = "datacenter_ip" + RESIDENTIAL_PROXY = "residential_proxy" + RESIDENTIAL_PROXY_LOW_CONFIDENCE = "residential_proxy_low_confidence" + RESIDENTIAL_PROXY_MEDIUM_CONFIDENCE = "residential_proxy_medium_confidence" + RESIDENTIAL_PROXY_HIGH_CONFIDENCE = "residential_proxy_high_confidence" + VPN = "vpn" + VPN_PUBLIC = "vpn_public" + VPN_TIMEZONE = "vpn_timezone" + VPN_RELAY = "vpn_relay" + VPN_MOBILE = "vpn_mobile" + VPN_OS_MISMATCH = "vpn_os_mismatch" + VPN_LOW_CONFIDENCE = "vpn_low_confidence" + VPN_MEDIUM_CONFIDENCE = "vpn_medium_confidence" + VPN_HIGH_CONFIDENCE = "vpn_high_confidence" + IP_BLOCKLIST = "ip_blocklist" + IP_BLOCKLIST_EMAIL_SPAM = "ip_blocklist_email_spam" + IP_BLOCKLIST_ATTACK_SOURCE = "ip_blocklist_attack_source" + IP_REPUTATION = "ip_reputation" + IP_ABUSER = "ip_abuser" + NETWORK_ANOMALY = "network_anomaly" + BOGON_IP = "bogon_ip" + ANYCAST_IP = "anycast_ip" + LOCATION_SPOOFING = "location_spoofing" + GEO_MISMATCH = "geo_mismatch" + IOS_SIMULATOR = "ios_simulator" + SIMULATOR = "simulator" + ANDROID_EMULATOR = "android_emulator" + EMULATOR = "emulator" + VIRTUAL_MACHINE = "virtual_machine" + JAILBROKEN_DEVICE = "jailbroken_device" + JAILBREAK = "jailbreak" + ROOTED_DEVICE = "rooted_device" + ROOT_APPS = "root_apps" + PLAY_DEVICE_INTEGRITY_FAILED = "play_device_integrity_failed" + CLONED_APP = "cloned_app" + APP_CLONER = "app_cloner" + PLAY_APP_UNRECOGNIZED = "play_app_unrecognized" + DEVICE_FARM = "device_farm" + APP_ATTEST_KEY_CHURN = "app_attest_key_churn" + MITM_ATTACK = "mitm_attack" + FRIDA_DETECTED = "frida_detected" + FRIDA = "frida" + BROWSER_TAMPERING = "browser_tampering" + TAMPERING = "tampering" + ANTIDETECT_BROWSER = "antidetect_browser" + FINGERPRINT_SUPPRESSED = "fingerprint_suppressed" + DEVELOPER_TOOLS = "developer_tools" + REMOTE_CONTROL = "remote_control" + BOT = "bot" + AUTOMATION = "automation" + BAD_BOT = "bad_bot" + FETCH_METADATA_MISSING = "fetch_metadata_missing" + WEB_TICKET_MISSING = "web_ticket_missing" + WEB_TICKET_INVALID = "web_ticket_invalid" + HIGH_ACTIVITY = "high_activity" + INCOGNITO_MODE = "incognito_mode" + INCOGNITO = "incognito" + PRIVACY_SETTINGS = "privacy_settings" + EMBEDDED_WEB_VIEW = "embedded_web_view" + ACTIVE_CALL = "active_call" + ATTESTATION_MISSING = "attestation_missing" + ATTESTATION_FAILED = "attestation_failed" + ATTESTATION_DOWNGRADE = "attestation_downgrade" + DEVICE_INCONSISTENT = "device_inconsistent" + REPORT_INCOMPLETE = "report_incomplete" + PROBE_ERRORS = "probe_errors" + CUSTOM_ROOT_CA = "custom_root_ca" + SECONDARY_USER_PROFILE = "secondary_user_profile" + + +class SuspectLevel(_StrEnum): + """The band ``Event.suspect_level`` puts the suspect score in.""" + + LOW = "low" + MEDIUM = "medium" + HIGH = "high" + + +class Confidence(_StrEnum): + """How sure a detection is, as in ``EventTrigger.confidence``.""" + + LOW = "low" + MEDIUM = "medium" + HIGH = "high" + + +class EventState(_StrEnum): + """How far a submission has got, as in ``Event.state``. + + A read returns an ``ENRICHED`` or ``UNAVAILABLE`` event; ``PENDING`` is + what the API answers while it has not finished, which this SDK raises as + ``FingerlyEventPendingError``. + """ + + PENDING = "pending" + ENRICHED = "enriched" + UNAVAILABLE = "unavailable" + + +class Environment(_StrEnum): + """The key environment an event was recorded in, as in ``Event.environment``.""" + + PRODUCTION = "production" + STAGING = "staging" + DEVELOPMENT = "development" + + +class AttestationState(_StrEnum): + """The server's single hardware attestation verdict, ``Attestation.state``.""" + + ATTESTED = "attested" + NOT_ATTESTED = "not_attested" + FAILED = "failed" + + +class AttestationStatus(_StrEnum): + """The detail behind the verdict, ``Attestation.status``.""" + + VERIFIED = "verified" + INDETERMINATE = "indeterminate" + INVALID = "invalid" + ABSENT = "absent" + UNCONFIGURED = "unconfigured" + + +class AttestSkippedReason(_StrEnum): + """The app's own reason for sending no attestation, ``Attestation.attest_skipped``. + + Diagnostic only; it never lowers the score. + """ + + NOT_OFFERED = "not_offered" + UNSUPPORTED = "unsupported" + CHALLENGE_UNAVAILABLE = "challenge_unavailable" + KEY_ERROR = "key_error" + TIMEOUT = "timeout" + BACKOFF = "backoff" + INSTALL_UNAVAILABLE = "install_unavailable" + + +class VerifyReason(_StrEnum): + """Why :meth:`Events.verify` refused an event, or ``OK`` (``""``) when it passed. + + Members, in the order the checks run: + + - ``NOT_FOUND``: no event for the request id (``404 event_not_found``). + - ``TOO_OLD``: it occurred more than ``max_age_seconds`` ago, or its + ``occurred_at`` is missing or unreadable. + - ``TAG_MISMATCH``: its ``tag`` is not exactly the ``tag`` asked for. + - ``UNIDENTIFIABLE``: its ``visitor_id`` is empty. + - ``UNSCORED``: its ``suspect_score`` is ``None``. + - ``ALREADY_CONSUMED``: an earlier call consumed it. + """ + + OK = "" + NOT_FOUND = "not_found" + TOO_OLD = "too_old" + TAG_MISMATCH = "tag_mismatch" + UNIDENTIFIABLE = "unidentifiable" + UNSCORED = "unscored" + ALREADY_CONSUMED = "already_consumed" + + +class WebhookEventType(_StrEnum): + """The ``type`` of a webhook delivery. + + ``WEBHOOK_TEST`` is sent only on **Send test event** for one endpoint and + cannot be subscribed to. Ignore types you do not handle: a newer server + may send more. + """ + + IDENTIFICATION_COMPLETED = "identification.completed" + IDENTIFICATION_REFUSED = "identification.refused" + VISITOR_SUSPECT = "visitor.suspect" + BILLING_STATUS_CHANGED = "billing.status_changed" + USAGE_DAILY_SETTLED = "usage.daily_settled" + WEBHOOK_TEST = "webhook.test" diff --git a/src/fingerly/_models.py b/src/fingerly/_models.py index 99cb8ea..3bbb80c 100644 --- a/src/fingerly/_models.py +++ b/src/fingerly/_models.py @@ -11,8 +11,9 @@ from collections.abc import Mapping, Sequence from dataclasses import dataclass, field, replace from datetime import datetime, timezone -from typing import Any, Literal, Optional +from typing import Any, Optional +from ._enums import Signal, VerifyReason from ._errors import FingerlyError _INSTANT = re.compile( @@ -21,81 +22,9 @@ r"(?:[Zz]|(?P[+-])(?P\d{2}):?(?P\d{2}))\Z" ) -#: Canonical v3 risk signal and signal-group names reported in event triggers -#: and archived risk assessments. -SIGNAL_NAMES: tuple[str, ...] = ( - "tor", - "datacenter_proxy", - "proxy", - "datacenter_ip", - "residential_proxy", - "residential_proxy_low_confidence", - "residential_proxy_medium_confidence", - "residential_proxy_high_confidence", - "vpn", - "vpn_public", - "vpn_timezone", - "vpn_relay", - "vpn_mobile", - "vpn_os_mismatch", - "vpn_low_confidence", - "vpn_medium_confidence", - "vpn_high_confidence", - "ip_blocklist", - "ip_blocklist_email_spam", - "ip_blocklist_attack_source", - "ip_reputation", - "ip_abuser", - "network_anomaly", - "bogon_ip", - "anycast_ip", - "location_spoofing", - "geo_mismatch", - "ios_simulator", - "simulator", - "android_emulator", - "emulator", - "virtual_machine", - "jailbroken_device", - "jailbreak", - "rooted_device", - "root_apps", - "play_device_integrity_failed", - "cloned_app", - "app_cloner", - "play_app_unrecognized", - "device_farm", - "app_attest_key_churn", - "mitm_attack", - "frida_detected", - "frida", - "browser_tampering", - "tampering", - "antidetect_browser", - "fingerprint_suppressed", - "developer_tools", - "remote_control", - "bot", - "automation", - "bad_bot", - "fetch_metadata_missing", - "web_ticket_missing", - "web_ticket_invalid", - "high_activity", - "incognito_mode", - "incognito", - "privacy_settings", - "embedded_web_view", - "active_call", - "attestation_missing", - "attestation_failed", - "attestation_downgrade", - "device_inconsistent", - "report_incomplete", - "probe_errors", - "custom_root_ca", - "secondary_user_profile", -) +#: Every :class:`Signal` value, in declaration order. Kept for callers that +#: want plain strings; prefer the :class:`Signal` members. +SIGNAL_NAMES: tuple[str, ...] = tuple(signal.value for signal in Signal) @dataclass(frozen=True) @@ -104,9 +33,10 @@ class EventTrigger: Attributes: signal: The signal group, such as ``vpn``, ``bot`` or - ``attestation_failed``. + ``attestation_failed``; compare with :class:`Signal` members. weight: The group's combined weight in this score. - confidence: ``low``, ``medium`` or ``high``. + confidence: ``low``, ``medium`` or ``high``, a :class:`Confidence` + value. """ signal: str @@ -119,12 +49,14 @@ class Attestation: """Platform-neutral hardware attestation verdict from an archived document. Attributes: - state: ``attested``, ``not_attested`` or ``failed``. + state: ``attested``, ``not_attested`` or ``failed``, an + :class:`AttestationState` value. status: ``verified``, ``indeterminate``, ``invalid``, ``absent`` or - ``unconfigured``. + ``unconfigured``, an :class:`AttestationStatus` value. attest_skipped: Native only: the app's own reason for sending no - attestation, such as ``not_offered``, ``unsupported`` or - ``timeout``. Diagnostic only; it never lowers the score. + attestation, an :class:`AttestSkippedReason` value such as + ``not_offered``, ``unsupported`` or ``timeout``. Diagnostic only; + it never lowers the score. downgrade: Native only: an unproven or rejected report named an install an attested device owns, so it was answered unidentifiable. @@ -187,6 +119,11 @@ class Event: network, IP classification and city-level location, risk, attestation and velocity), with no raw signals, user agent or address. + Closed string sets stay typed ``str`` and hold the value as sent, so a + value a newer server adds still parses. Compare them with the enum + members: ``state`` with :class:`EventState`, ``environment`` with + :class:`Environment`, ``suspect_level`` with :class:`SuspectLevel`. + Attributes: project_id: The Fingerly project the event belongs to, as a UUID string. ``None`` when an older server did not send it. @@ -319,18 +256,6 @@ class ConsumeResult: first: bool -#: Why :meth:`Events.verify` refused an event, or ``""`` when it passed. -VerifyReason = Literal[ - "", - "not_found", - "too_old", - "tag_mismatch", - "unidentifiable", - "unscored", - "already_consumed", -] - - @dataclass(frozen=True) class VerifyResult: """The outcome of :meth:`Events.verify`. @@ -338,9 +263,10 @@ class VerifyResult: Attributes: ok: True when every check passed, and the event was consumed unless ``consume=False``. - reason: ``""`` when ``ok``; otherwise the first check that failed: - ``not_found``, ``too_old``, ``tag_mismatch``, ``unidentifiable``, - ``unscored`` or ``already_consumed``. + reason: A :class:`VerifyReason` member: ``VerifyReason.OK`` (``""``) + when ``ok``; otherwise the first check that failed: ``not_found``, + ``too_old``, ``tag_mismatch``, ``unidentifiable``, ``unscored`` or + ``already_consumed``. It compares equal to those strings. event: The event read, or None only for ``not_found``. When its ``occurred_at`` was missing or unreadable (reason ``too_old``), ``event.occurred_at`` is the earliest UTC ``datetime`` and @@ -406,14 +332,14 @@ def failed_check( level and triggers are never looked at. """ if occurred is None or (now - occurred).total_seconds() > max_age_seconds: - return "too_old" + return VerifyReason.TOO_OLD if tag is not None and (event.tag or "") != tag: - return "tag_mismatch" + return VerifyReason.TAG_MISMATCH if not event.visitor_id: - return "unidentifiable" + return VerifyReason.UNIDENTIFIABLE if event.suspect_score is None: - return "unscored" - return "" + return VerifyReason.UNSCORED + return VerifyReason.OK def parse_device_check_bits(payload: Mapping[str, Any]) -> DeviceCheckBits: diff --git a/tests/test_enums.py b/tests/test_enums.py new file mode 100644 index 0000000..dcd18dd --- /dev/null +++ b/tests/test_enums.py @@ -0,0 +1,349 @@ +"""The exported enums match the server's closed string sets and stay strings. + +The pinned lists below mirror the server sources named beside each one. When +the server checkout sits next to this SDK (the integration workspace) or +``FINGERLY_SERVER_DIR`` names it, the server tests read those sources too, so a +signal added or retired there fails here until the SDK follows. +""" + +from __future__ import annotations + +import json +import os +import re +from enum import Enum +from pathlib import Path +from typing import Optional + +import pytest +from conftest import Recorder, event_body, json_response + +import fingerly +from fingerly import ( + SIGNAL_NAMES, + AttestationState, + AttestationStatus, + AttestSkippedReason, + Confidence, + Environment, + EventState, + Fingerly, + Signal, + SuspectLevel, + VerifyReason, + WebhookEventType, +) +from fingerly._models import parse_document, parse_event + +# server/domain/risk/signals.go (Signal) and groups.go (Group). +SERVER_SIGNALS = { + "active_call", + "android_emulator", + "antidetect_browser", + "anycast_ip", + "app_attest_key_churn", + "app_cloner", + "attestation_downgrade", + "attestation_failed", + "attestation_missing", + "automation", + "bad_bot", + "bogon_ip", + "bot", + "browser_tampering", + "cloned_app", + "custom_root_ca", + "datacenter_ip", + "datacenter_proxy", + "developer_tools", + "device_farm", + "device_inconsistent", + "embedded_web_view", + "emulator", + "fetch_metadata_missing", + "fingerprint_suppressed", + "frida", + "frida_detected", + "geo_mismatch", + "high_activity", + "incognito", + "incognito_mode", + "ios_simulator", + "ip_abuser", + "ip_blocklist", + "ip_blocklist_attack_source", + "ip_blocklist_email_spam", + "ip_reputation", + "jailbreak", + "jailbroken_device", + "location_spoofing", + "mitm_attack", + "network_anomaly", + "play_app_unrecognized", + "play_device_integrity_failed", + "privacy_settings", + "probe_errors", + "proxy", + "remote_control", + "report_incomplete", + "residential_proxy", + "residential_proxy_high_confidence", + "residential_proxy_low_confidence", + "residential_proxy_medium_confidence", + "root_apps", + "rooted_device", + "secondary_user_profile", + "simulator", + "tampering", + "tor", + "virtual_machine", + "vpn", + "vpn_high_confidence", + "vpn_low_confidence", + "vpn_medium_confidence", + "vpn_mobile", + "vpn_os_mismatch", + "vpn_public", + "vpn_relay", + "vpn_timezone", + "web_ticket_invalid", + "web_ticket_missing", +} + +PINNED: dict[type[Enum], set[str]] = { + Signal: SERVER_SIGNALS, + # server/models/enums.go (SuspectLevel). + SuspectLevel: {"low", "medium", "high"}, + # server/domain/risk/signals.go (Confidence). + Confidence: {"low", "medium", "high"}, + # server/models/event.go (EventState). + EventState: {"pending", "enriched", "unavailable"}, + # server/models/enums.go (Environment). + Environment: {"production", "staging", "development"}, + # server/services/android_trust.go (AttestationAttested and siblings). + AttestationState: {"attested", "not_attested", "failed"}, + # server/services/android_trust.go (AttestationReport.Status). + AttestationStatus: { + "verified", + "indeterminate", + "invalid", + "absent", + "unconfigured", + }, + # server/services/android_trust.go (AttestSkippedReasons). + AttestSkippedReason: { + "not_offered", + "unsupported", + "challenge_unavailable", + "key_error", + "timeout", + "backoff", + "install_unavailable", + }, + # server/models/webhook.go (WebhookEventType). + WebhookEventType: { + "identification.completed", + "identification.refused", + "visitor.suspect", + "billing.status_changed", + "usage.daily_settled", + "webhook.test", + }, + # Produced by this SDK's own verify checks. + VerifyReason: { + "", + "not_found", + "too_old", + "tag_mismatch", + "unidentifiable", + "unscored", + "already_consumed", + }, +} + +ENUMS = list(PINNED) + + +def _server_dir() -> Optional[Path]: + """The server checkout: ``FINGERLY_SERVER_DIR``, or the workspace sibling.""" + configured = os.environ.get("FINGERLY_SERVER_DIR") + parents = Path(__file__).resolve().parents + if configured: + path = Path(configured) + elif len(parents) > 4: + path = parents[4] / "server" + else: + return None + return path if (path / "domain" / "risk" / "signals.go").is_file() else None + + +SERVER = _server_dir() +needs_server = pytest.mark.skipif( + SERVER is None, reason="server checkout not found; set FINGERLY_SERVER_DIR" +) + + +def _go_constants(relative: str, go_type: str) -> set[str]: + """Every ``Name go_type = "value"`` constant in one server source file.""" + assert SERVER is not None + source = (SERVER / relative).read_text(encoding="utf-8") + return set(re.findall(rf'\b{go_type}\s*=\s*"([^"]*)"', source)) + + +def _go_block(relative: str, pattern: str) -> str: + assert SERVER is not None + source = (SERVER / relative).read_text(encoding="utf-8") + match = re.search(pattern, source, re.DOTALL) + assert match is not None, f"{pattern!r} not found in {relative}" + return match.group(1) + + +class TestPinnedValues: + @pytest.mark.parametrize("enum", ENUMS, ids=lambda enum: enum.__name__) + def test_values_match_the_server(self, enum: type[Enum]) -> None: + values = [member.value for member in enum] + assert len(values) == len(set(values)) + assert set(values) == PINNED[enum] + + @pytest.mark.parametrize("enum", ENUMS, ids=lambda enum: enum.__name__) + def test_names_are_the_upper_snake_value(self, enum: type[Enum]) -> None: + for member in enum: + if member.value == "": + assert member.name == "OK" + continue + assert member.name == re.sub(r"[^A-Za-z0-9]", "_", member.value).upper() + + def test_signal_names_is_every_signal_in_order(self) -> None: + assert [member.value for member in Signal] == list(SIGNAL_NAMES) + + def test_every_enum_is_exported(self) -> None: + for enum in ENUMS: + assert enum.__name__ in fingerly.__all__ + assert getattr(fingerly, enum.__name__) is enum + + +@needs_server +class TestServerSources: + def test_signals(self) -> None: + server = _go_constants("domain/risk/signals.go", "Signal") | _go_constants( + "domain/risk/groups.go", "Group" + ) + assert server == {member.value for member in Signal} + + def test_suspect_levels_and_environments(self) -> None: + assert _go_constants("models/enums.go", "SuspectLevel") == { + member.value for member in SuspectLevel + } + assert _go_constants("models/enums.go", "Environment") == { + member.value for member in Environment + } + + def test_confidence(self) -> None: + assert _go_constants("domain/risk/signals.go", "Confidence") == { + member.value for member in Confidence + } + + def test_event_states(self) -> None: + assert _go_constants("models/event.go", "EventState") == { + member.value for member in EventState + } + + def test_webhook_event_types(self) -> None: + assert _go_constants("models/webhook.go", "WebhookEventType") == { + member.value for member in WebhookEventType + } + + def test_attestation(self) -> None: + trust = "services/android_trust.go" + states = _go_block(trust, r"(\n\tAttestationAttested\s.*?)\n\)") + assert set(re.findall(r'"([a-z_]+)"', states)) == { + member.value for member in AttestationState + } + status = _go_block( + trust, r"// Status is the detail behind State:(.*?)\n\s*Status " + ) + assert set(re.findall(r"[a-z_]+", status)) - {"or"} == { + member.value for member in AttestationStatus + } + skipped = _go_block(trust, r"AttestSkippedReasons = \[\]string\{(.*?)\}") + assert set(re.findall(r'"([a-z_]+)"', skipped)) == { + member.value for member in AttestSkippedReason + } + + +class TestStringBehaviour: + def test_members_are_their_raw_strings(self) -> None: + raw: str = "high" + assert raw == SuspectLevel.HIGH + assert isinstance(SuspectLevel.HIGH, str) + assert str(Signal.FINGERPRINT_SUPPRESSED) == "fingerprint_suppressed" + assert f"{WebhookEventType.VISITOR_SUSPECT}" == "visitor.suspect" + assert f"{SuspectLevel.LOW:>5}" == " low" + assert json.dumps({"level": SuspectLevel.MEDIUM}) == '{"level": "medium"}' + + def test_members_hash_like_their_strings(self) -> None: + assert Signal.TOR in {"tor", "vpn"} + assert {"high": 1}[SuspectLevel.HIGH] == 1 + by_signal: dict[str, int] = {Signal.BOT: 1} + assert by_signal["bot"] == 1 + + def test_ok_is_falsy_and_every_refusal_truthy(self) -> None: + assert not VerifyReason.OK + assert all(member for member in VerifyReason if member is not VerifyReason.OK) + + def test_parsed_fields_compare_with_members(self) -> None: + event = parse_event( + event_body( + suspect_level="high", + triggers=[ + {"signal": "fingerprint_suppressed", "weight": 9}, + {"signal": "vpn", "weight": 5, "confidence": "medium"}, + ], + ) + ) + signals = [trigger.signal for trigger in event.triggers] + assert event.suspect_level == SuspectLevel.HIGH + assert event.state == EventState.ENRICHED + assert event.environment == Environment.DEVELOPMENT + assert Signal.FINGERPRINT_SUPPRESSED in signals + assert event.triggers[1].confidence == Confidence.MEDIUM + + def test_unknown_values_still_parse(self) -> None: + event = parse_event( + event_body( + state="some_future_state", + suspect_level="extreme", + triggers=[{"signal": "a_future_signal", "weight": 1}], + ) + ) + assert event.suspect_level == "extreme" + assert event.suspect_level not in set(SuspectLevel) + assert event.triggers[0].signal == "a_future_signal" + assert type(event.triggers[0].signal) is str + + def test_attestation_compares_with_members(self) -> None: + document = parse_document( + { + "schema": 3, + "request_id": "request-1", + "occurred_at": "2026-11-01T00:00:00Z", + "sdk": {"platform": "android", "version": "0.3.0"}, + "attestation": { + "state": "not_attested", + "status": "absent", + "attest_skipped": "timeout", + }, + } + ) + assert document.attestation is not None + assert document.attestation.state == AttestationState.NOT_ATTESTED + assert document.attestation.status == AttestationStatus.ABSENT + assert document.attestation.attest_skipped == AttestSkippedReason.TIMEOUT + + def test_a_level_member_is_sent_as_its_value(self) -> None: + recorder = Recorder(json_response({"rows": [], "page": 1, "page_size": 10})) + with Fingerly( + secret_key="fly_sk_development_enums", transport=recorder.transport() + ) as client: + client.events.list(level=SuspectLevel.HIGH) + assert dict(recorder.requests[0].url.params)["level"] == "high" diff --git a/tests/test_events_verify.py b/tests/test_events_verify.py index b15cc96..0a1ad1d 100644 --- a/tests/test_events_verify.py +++ b/tests/test_events_verify.py @@ -24,6 +24,7 @@ FingerlyAPIError, FingerlyEventAlreadyConsumedError, FingerlyEventPendingError, + VerifyReason, VerifyResult, ) @@ -204,7 +205,9 @@ def test_ok_consumes_once_after_the_read(self) -> None: def test_not_found_on_the_read(self) -> None: get = error_response("event_not_found", 404) for result, recorder in verify_both(get): - assert result == VerifyResult(ok=False, reason="not_found", event=None) + assert result == VerifyResult( + ok=False, reason=VerifyReason.NOT_FOUND, event=None + ) assert posts(recorder) == 0 def test_too_old(self) -> None: @@ -311,7 +314,9 @@ def test_not_found_on_consume(self) -> None: get = json_response(fresh_event()) post = error_response("event_not_found", 404) for result, recorder in verify_both(get, post): - assert result == VerifyResult(ok=False, reason="not_found", event=None) + assert result == VerifyResult( + ok=False, reason=VerifyReason.NOT_FOUND, event=None + ) assert posts(recorder) == 1 def test_other_consume_errors_are_raised(self) -> None: From 4dd3065bf68e0a846210e4749026df0260bd9d0f Mon Sep 17 00:00:00 2001 From: muzakon Date: Tue, 17 Nov 2026 16:07:32 +0300 Subject: [PATCH 2/4] Match the signal list to the server Add repeated_reinstall, device_activity_high and device_activity_very_high, and drop the retired app_attest_key_churn. --- src/fingerly/_enums.py | 4 +++- tests/test_enums.py | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/fingerly/_enums.py b/src/fingerly/_enums.py index 9c89a81..367708f 100644 --- a/src/fingerly/_enums.py +++ b/src/fingerly/_enums.py @@ -75,7 +75,9 @@ class Signal(_StrEnum): APP_CLONER = "app_cloner" PLAY_APP_UNRECOGNIZED = "play_app_unrecognized" DEVICE_FARM = "device_farm" - APP_ATTEST_KEY_CHURN = "app_attest_key_churn" + REPEATED_REINSTALL = "repeated_reinstall" + DEVICE_ACTIVITY_HIGH = "device_activity_high" + DEVICE_ACTIVITY_VERY_HIGH = "device_activity_very_high" MITM_ATTACK = "mitm_attack" FRIDA_DETECTED = "frida_detected" FRIDA = "frida" diff --git a/tests/test_enums.py b/tests/test_enums.py index dcd18dd..3536393 100644 --- a/tests/test_enums.py +++ b/tests/test_enums.py @@ -41,7 +41,6 @@ "android_emulator", "antidetect_browser", "anycast_ip", - "app_attest_key_churn", "app_cloner", "attestation_downgrade", "attestation_failed", @@ -56,6 +55,8 @@ "datacenter_ip", "datacenter_proxy", "developer_tools", + "device_activity_high", + "device_activity_very_high", "device_farm", "device_inconsistent", "embedded_web_view", @@ -85,6 +86,7 @@ "probe_errors", "proxy", "remote_control", + "repeated_reinstall", "report_incomplete", "residential_proxy", "residential_proxy_high_confidence", From c4a787577db9e4a2d26eb9a1c35b426a793aea29 Mon Sep 17 00:00:00 2001 From: muzakon Date: Tue, 17 Nov 2026 16:07:32 +0300 Subject: [PATCH 3/4] Use the named constants in the README --- README.md | 46 ++++++++++++++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index e4b8cfb..c83e8cc 100644 --- a/README.md +++ b/README.md @@ -71,7 +71,7 @@ import os from flask import Flask, abort, request -from fingerly import verify_webhook +from fingerly import WebhookEventType, verify_webhook app = Flask(__name__) @@ -86,7 +86,8 @@ def fingerly_webhook(): ): abort(400) delivery = request.get_json() - print(delivery["type"]) + if delivery["type"] == WebhookEventType.VISITOR_SUSPECT: + print(delivery["data"]) return "", 204 ``` @@ -151,7 +152,16 @@ The archived `document` arrives moments after the event itself, so check `has_do - `ip_network` is the network the request came from (an IPv4 /24 or an IPv6 /40, such as `203.0.113.0/24`); the API never returns the address. - When a submission is unidentifiable (`event.identifiable is False`, such as insufficient entropy, a genuine embedded WebView, or an unmatched high-risk Web payload), `event.visitor_id` is `""`. There are no `deferred_token`, `deferred_signals` or `supplements` fields in `v: 3`. - `document`, when available, is an allow-listed view of the archived request with no raw signals, user agent or address. `event.parse_document()` decodes it into a typed `EventDocument` (including `attestation: Optional[Attestation]`). A native `Attestation` also carries `attest_skipped` (the app's reason for sending no proof) and `downgrade` (the report named an install an attested device owns). -- `SIGNAL_NAMES` lists the canonical signal identifiers, including the `v: 3` anti-spoofing and integrity signals `"attestation_failed"`, `"attestation_downgrade"`, `"device_inconsistent"`, `"report_incomplete"`, `"probe_errors"`, `"fetch_metadata_missing"`, `"web_ticket_missing"`, `"web_ticket_invalid"`, `"tampering"`, `"custom_root_ca"` and `"secondary_user_profile"`. +- `suspect_level`, `state`, `environment`, each trigger's `signal` and `confidence`, and an `Attestation`'s `state`, `status` and `attest_skipped` hold the string the API sent. Compare them with the matching enum: `SuspectLevel`, `EventState`, `Environment`, `Signal`, `Confidence`, `AttestationState`, `AttestationStatus` and `AttestSkippedReason`. Every member is a `str` equal to its value, so `event.suspect_level == SuspectLevel.HIGH` and `Signal.FINGERPRINT_SUPPRESSED in signals` work on plain strings, and a value a newer server adds still parses. Compare rather than convert: `SuspectLevel(value)` raises `ValueError` for a value this release does not know. +- `Signal` names every signal group and detector, including the `v: 3` anti-spoofing and integrity signals `ATTESTATION_FAILED`, `ATTESTATION_DOWNGRADE`, `DEVICE_INCONSISTENT`, `REPORT_INCOMPLETE`, `PROBE_ERRORS`, `FETCH_METADATA_MISSING`, `WEB_TICKET_MISSING`, `WEB_TICKET_INVALID`, `TAMPERING`, `CUSTOM_ROOT_CA` and `SECONDARY_USER_PROFILE`. `SIGNAL_NAMES` holds the same values as plain strings. + +```python +from fingerly import Signal, SuspectLevel + +signals = [trigger.signal for trigger in event.triggers] +if event.suspect_level == SuspectLevel.HIGH or Signal.FINGERPRINT_SUPPRESSED in signals: + send_to_review(event) +``` - `suspect_score` is `None` when the request was not scored, and must not be treated as zero. - `project_id` is the UUID string of the Fingerly project the event belongs to, on both `events.get` and the rows of `events.list`; it is `None` when an older server does not send it. - `Event` declares every documented field as an attribute and falls back to the decoded body for fields added later, so a new server field needs no SDK upgrade. @@ -164,24 +174,28 @@ The archived `document` arrives moments after the event itself, so check `has_do Send the browser's `requestId` to your server and verify it there with a server-only key. `fingerly.events.verify` reads the event and runs these checks in order, stopping at the first that fails: -| Order | Reason | Fails when | -| --- | --- | --- | -| 1 | `not_found` | The event does not exist for this key's environment. | -| 2 | `too_old` | It occurred more than `max_age_seconds` ago (300 by default). A missing or unreadable `occurred_at` fails too. | -| 3 | `tag_mismatch` | You passed `tag` and the event's tag is not exactly that. | -| 4 | `unidentifiable` | The event has no visitor id. | -| 5 | `unscored` | The event has no `suspect_score`. | -| 6 | `already_consumed` | The event was consumed before. | +| Order | Reason | `VerifyReason` | Fails when | +| --- | --- | --- | --- | +| 1 | `not_found` | `NOT_FOUND` | The event does not exist for this key's environment. | +| 2 | `too_old` | `TOO_OLD` | It occurred more than `max_age_seconds` ago (300 by default). A missing or unreadable `occurred_at` fails too. | +| 3 | `tag_mismatch` | `TAG_MISMATCH` | You passed `tag` and the event's tag is not exactly that. | +| 4 | `unidentifiable` | `UNIDENTIFIABLE` | The event has no visitor id. | +| 5 | `unscored` | `UNSCORED` | The event has no `suspect_score`. | +| 6 | `already_consumed` | `ALREADY_CONSUMED` | The event was consumed before. | -Consumption comes last, only when every other check passed, so one event backs one decision: a replayed `requestId` answers `already_consumed`. Pass `consume=False` to check without consuming. The result is a `VerifyResult` with `ok`, `reason` (`""` when `ok`) and `event` (`None` only for `not_found`). +Consumption comes last, only when every other check passed, so one event backs one decision: a replayed `requestId` answers `already_consumed`. Pass `consume=False` to check without consuming. The result is a `VerifyResult` with `ok`, `reason` (a `VerifyReason`, `VerifyReason.OK` or `""` when `ok`, and equal to the strings above otherwise) and `event` (`None` only for `not_found`). `verify` never judges the score: that policy stays with you. Check `suspect_level` or `suspect_score` after `ok`. ```python +from fingerly import SuspectLevel, VerifyReason + result = fingerly.events.verify(request_id, tag="checkout") -if not result.ok: +if result.reason == VerifyReason.ALREADY_CONSUMED: + refuse_replay() +elif not result.ok: refuse(result.reason) -elif result.event.suspect_level == "high": +elif result.event.suspect_level == SuspectLevel.HIGH: send_to_review(result.event) else: allow() @@ -234,7 +248,7 @@ A `503` or a transport failure leaves the token held, and the SDK retries the id The example under [Getting started](#getting-started) verifies a delivery in Flask. -`identification.completed` and `visitor.suspect` deliveries carry the event's project as `data["project_id"]`; `identification.refused` carries it only when the refused request named a known key. The SDK passes the payload through unmodelled, so read it from the parsed JSON. +`identification.completed` and `visitor.suspect` deliveries carry the event's project as `data["project_id"]`; `identification.refused` carries it only when the refused request named a known key. The SDK passes the payload through unmodelled, so read it from the parsed JSON. Compare its `type` with `WebhookEventType` (`IDENTIFICATION_COMPLETED`, `IDENTIFICATION_REFUSED`, `VISITOR_SUSPECT`, `BILLING_STATUS_CHANGED`, `USAGE_DAILY_SETTLED`, and `WEBHOOK_TEST` from **Send test event**), and ignore types you do not handle. Verify the exact raw bytes before JSON parsing. Signatures cover the timestamp and body. The default replay tolerance is 300 seconds; persist processed webhook IDs to deduplicate deliveries. During signing-secret rotation, any matching signature in the comma-separated header is accepted; only the first 32 are read. The function never raises for malformed input: bad input is a failed verification, not an exception. @@ -609,7 +623,7 @@ The vendored synthetic contract snapshot makes tests independent of sibling repo
Source structure -`_client.py` holds both clients and their event reads. `_http.py` is the connection pool both clients and the proxy send through, with its deadline and body cap. `_transport.py` builds requests and interprets responses, so the two clients share one definition of what a request is and what a failure means. `_models.py` owns `Event`, `EventPage` and their parsing. `_webhooks.py` verifies signatures. `_proxy.py` owns every proxy decision, with `_asgi.py` and `_wsgi.py` as thin adapters that only read a request and write a response, so the two standards cannot drift apart. `_config.py` validates every caller-supplied option: keys, origins, API versions and durations, all before any network access. `_errors.py` holds the exception hierarchy. `_version.py` holds the version everything else reads. `__init__.py` only exposes the public API. +`_client.py` holds both clients and their event reads. `_http.py` is the connection pool both clients and the proxy send through, with its deadline and body cap. `_transport.py` builds requests and interprets responses, so the two clients share one definition of what a request is and what a failure means. `_models.py` owns `Event`, `EventPage` and their parsing. `_enums.py` holds the string enums the models and webhooks compare against. `_webhooks.py` verifies signatures. `_proxy.py` owns every proxy decision, with `_asgi.py` and `_wsgi.py` as thin adapters that only read a request and write a response, so the two standards cannot drift apart. `_config.py` validates every caller-supplied option: keys, origins, API versions and durations, all before any network access. `_errors.py` holds the exception hierarchy. `_version.py` holds the version everything else reads. `__init__.py` only exposes the public API.
From 601d5410cb4e42851544605de317fc08d90a3858 Mon Sep 17 00:00:00 2001 From: muzakon Date: Tue, 17 Nov 2026 16:09:50 +0300 Subject: [PATCH 4/4] Release 0.4.0 --- CHANGELOG.md | 18 ++++++++++++++++++ README.md | 4 ++-- src/fingerly/_version.py | 2 +- tests/test_frameworks.py | 4 ++-- tests/test_proxy.py | 2 +- 5 files changed, 24 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d1183dd..2dfe657 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,23 @@ # Changelog +## 0.4.0 + +- Added `str` enums for the fixed values the API and webhooks send: + `Signal`, `SuspectLevel`, `Confidence`, `EventState`, `Environment`, + `AttestationState`, `AttestationStatus`, `AttestSkippedReason`, + `VerifyReason` and `WebhookEventType`. Every member equals and hashes like + its raw string, so `event.suspect_level == SuspectLevel.HIGH` and + `Signal.FINGERPRINT_SUPPRESSED in signals` work on parsed events. Model + fields stay typed `str` and hold the value as sent, so a value a newer + server adds still parses as a plain string. +- `VerifyReason` is an enum class instead of a `Literal` alias, and + `VerifyResult.reason` is a `VerifyReason` member: `VerifyReason.OK` (equal + to `""`) when `ok`, otherwise the failed check. This is a breaking change + for type checkers; the runtime values are the same strings. +- `Signal` and `SIGNAL_NAMES` match the server: they include + `repeated_reinstall`, `device_activity_high` and + `device_activity_very_high`, and no longer list `app_attest_key_churn`. + ## 0.3.0 - Added `fingerly.events.verify(request_id, max_age_seconds=300, tag=None, diff --git a/README.md b/README.md index c83e8cc..1f6689f 100644 --- a/README.md +++ b/README.md @@ -32,7 +32,7 @@ Two clients share one API: `Fingerly` for synchronous code such as Django and Fl **2. Install.** ```sh -pip install "fingerly>=0.3.0" +pip install "fingerly>=0.4.0" ``` **3. Read an event.** @@ -315,7 +315,7 @@ Responses are marked `no-store`. A redirect is never followed, whatever transpor Incoming headers follow the sanitize-and-restore sequence: all incoming `x-fingerly-*`, `cookie` and `authorization` headers are stripped, restoring `x-fingerly-sdk-platform` only when it matches an exact lowercase native or bridge platform (`ios`, `android`, `react-native`, `react-native-ios`, `react-native-android`, `flutter`, `flutter-ios`, `flutter-android`, `lynx-ios`, `lynx-android`, `capacitor`, `kotlin-multiplatform`). Requests carrying neither `Origin` nor a validated `x-fingerly-sdk-platform` are rejected locally with `400` (`missing_origin`), and `x-fingerly-origin` is never synthesized from `Host`, `Referer` or the request URL. Exactly one channel goes upstream: a request with an `Origin` is forwarded as a browser call with `x-fingerly-origin` and without the platform header, as the API treats the same request sent to it directly. -Alongside verified proxy metadata (`x-fingerly-host` included), only `content-type`, `x-api-key`, `user-agent`, `idempotency-key`, `sec-fetch-*` and `sec-ch-ua-*` are forwarded. Customer cookies and authorization headers are never passed on. The proxy reports itself upstream as `python/0.3.0` in `x-fingerly-proxy-version`, which the dashboard shows per proxy, and sends `fingerly-python/0.3.0` as its user agent. +Alongside verified proxy metadata (`x-fingerly-host` included), only `content-type`, `x-api-key`, `user-agent`, `idempotency-key`, `sec-fetch-*` and `sec-ch-ua-*` are forwarded. Customer cookies and authorization headers are never passed on. The proxy reports itself upstream as `python/0.4.0` in `x-fingerly-proxy-version`, which the dashboard shows per proxy, and sends `fingerly-python/0.4.0` as its user agent. Back to the browser it relays only `content-type`, `x-request-id`, `ratelimit-limit`, `ratelimit-remaining` and `retry-after`, plus its own `cache-control: no-store` and a `content-length` for the decoded body. A content blocker can match a response header by name, so an allowlist is what keeps anything naming Fingerly off the page. diff --git a/src/fingerly/_version.py b/src/fingerly/_version.py index d60e763..6e7a45a 100644 --- a/src/fingerly/_version.py +++ b/src/fingerly/_version.py @@ -4,4 +4,4 @@ send and the version the proxy reports upstream all come from here. """ -__version__ = "0.3.0" +__version__ = "0.4.0" diff --git a/tests/test_frameworks.py b/tests/test_frameworks.py index 7e8581c..de58600 100644 --- a/tests/test_frameworks.py +++ b/tests/test_frameworks.py @@ -108,7 +108,7 @@ def test_forwards_from_a_route_at_the_issued_path(self) -> None: assert str(forwarded.url) == INGEST assert forwarded.headers["x-fingerly-client-ip"] == "203.0.113.5" assert forwarded.headers["x-fingerly-proxy-key"] == PROXY_KEY - assert forwarded.headers["x-fingerly-proxy-version"] == "python/0.3.0" + assert forwarded.headers["x-fingerly-proxy-version"] == "python/0.4.0" assert "cookie" not in forwarded.headers (missing_origin,) = self.post( @@ -224,7 +224,7 @@ def test_forwards_beside_the_host_app(self) -> None: forwarded = upstream.requests[0] assert forwarded.content == raw_v3 assert forwarded.headers["x-fingerly-client-ip"] == "203.0.113.5" - assert forwarded.headers["x-fingerly-proxy-version"] == "python/0.3.0" + assert forwarded.headers["x-fingerly-proxy-version"] == "python/0.4.0" assert "cookie" not in forwarded.headers native_forwarded = upstream.requests[1] assert native_forwarded.content == raw_v3 diff --git a/tests/test_proxy.py b/tests/test_proxy.py index c3509f3..439321d 100644 --- a/tests/test_proxy.py +++ b/tests/test_proxy.py @@ -243,7 +243,7 @@ def test_sends_only_vetted_visitor_metadata(self) -> None: assert upstream.headers["x-fingerly-origin"] == "https://shop.test" assert upstream.headers["x-fingerly-user-agent"] == "Firefox" assert upstream.headers["idempotency-key"] == "idem-1" - assert upstream.headers["x-fingerly-proxy-version"] == "python/0.3.0" + assert upstream.headers["x-fingerly-proxy-version"] == "python/0.4.0" assert "cookie" not in upstream.headers assert "authorization" not in upstream.headers