moving

Author: vdusek

tests/integration/test_actor.py

@@ -9,8 +9,10 @@
 from ._utils import get_random_resource_name, maybe_await
 from apify_client._models import (
     Actor,
+    ActorChargeEvent,
     ActorShort,
     Build,
+    FlatPricePerMonthActorPricingInfo,
     ListOfActors,
     ListOfWebhooks,
     PayPerEventActorPricingInfo,
@@ -22,6 +24,11 @@
 if TYPE_CHECKING:
     from apify_client import ApifyClient, ApifyClientAsync
 
+# Actor carrying pricing-info entries for every non-trivial variant: FLAT_PRICE_PER_MONTH,
+# both flat and tiered PRICE_PER_DATASET_ITEM, and tiered PAY_PER_EVENT with
+# `isPrimaryEvent` / `isOneTimeEvent` fields.
+ALL_PRICING_VARIANTS_ACTOR = 'apify/facebook-pages-scraper'
+
 
 async def test_get_public_actor(client: ApifyClient | ApifyClientAsync) -> None:
     """Test getting a public Actor by ID."""
@@ -368,40 +375,95 @@ async def test_actor_default_build_wait_for_finish(client: ApifyClient | ApifyCl
     assert isinstance(build, Build)
 
 
-async def test_get_actor_with_tiered_pricing(client: ApifyClient | ApifyClientAsync) -> None:
-    """Regression test for apify/apify-client-python#811.
+async def test_actor_get_parses_tiered_price_per_dataset_item(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test that actor.get() parses PRICE_PER_DATASET_ITEM entries with tieredPricing.
 
-    `apify/facebook-pages-scraper` historically returns `pricingInfos` entries that use tiered
-    pricing — both `PRICE_PER_DATASET_ITEM` with `tieredPricing` (instead of `pricePerUnitUsd`)
-    and `PAY_PER_EVENT` with `eventTieredPricingUsd` (instead of `eventPriceUsd`). Earlier
-    versions of the Pydantic models required the flat-price fields and rejected the response.
+    Tiered-PPD actors return `tieredPricing: {FREE, BRONZE, SILVER, GOLD, PLATINUM, DIAMOND}`
+    instead of a flat `pricePerUnitUsd`.
     """
-    actor = await maybe_await(client.actor('apify/facebook-pages-scraper').get())
+    actor = await maybe_await(client.actor(ALL_PRICING_VARIANTS_ACTOR).get())
     assert isinstance(actor, Actor)
-    assert actor.pricing_infos is not None
+    assert actor.pricing_infos
 
-    tiered_ppr = [
-        pi
-        for pi in actor.pricing_infos
-        if isinstance(pi, PricePerDatasetItemActorPricingInfo) and pi.tiered_pricing is not None
-    ]
-    assert tiered_ppr, 'expected at least one PRICE_PER_DATASET_ITEM entry with tiered_pricing'
-    tiered_pricing = tiered_ppr[0].tiered_pricing
-    assert tiered_pricing is not None
-    tiered_entry = next(iter(tiered_pricing.values()))
-    assert tiered_entry.tiered_price_per_unit_usd >= 0
-
-    tiered_ppe_events = [
-        event
-        for pi in actor.pricing_infos
-        if isinstance(pi, PayPerEventActorPricingInfo)
-        and pi.pricing_per_event is not None
-        and pi.pricing_per_event.actor_charge_events is not None
-        for event in pi.pricing_per_event.actor_charge_events.values()
-        if event.event_tiered_pricing_usd is not None
+    tiered_ppd_entries = [
+        info
+        for info in actor.pricing_infos
+        if isinstance(info, PricePerDatasetItemActorPricingInfo) and info.tiered_pricing is not None
     ]
-    assert tiered_ppe_events, 'expected at least one PAY_PER_EVENT charge event with event_tiered_pricing_usd'
-    event_tiered_pricing = tiered_ppe_events[0].event_tiered_pricing_usd
-    assert event_tiered_pricing is not None
-    tiered_event_entry = next(iter(event_tiered_pricing.values()))
-    assert tiered_event_entry.tiered_event_price_usd >= 0
+    assert tiered_ppd_entries, (
+        f'{ALL_PRICING_VARIANTS_ACTOR} should have at least one tiered PRICE_PER_DATASET_ITEM entry — '
+        'pick a different actor if pricing changed.'
+    )
+
+    # Fixture-drift guard: tiered pricing is only meaningful when it has more than one tier
+    # and the tiers actually differ in price. A degenerate single-tier or all-zero payload
+    # would silently look like flat pricing.
+    for entry in tiered_ppd_entries:
+        assert entry.tiered_pricing is not None
+        assert len(entry.tiered_pricing) >= 2, (
+            f'{ALL_PRICING_VARIANTS_ACTOR} tiered PPD entry has only {len(entry.tiered_pricing)} tier(s); '
+            'expected multiple tiers (e.g. FREE/BRONZE/SILVER/GOLD/PLATINUM/DIAMOND).'
+        )
+        distinct_prices = {t.tiered_price_per_unit_usd for t in entry.tiered_pricing.values()}
+        assert len(distinct_prices) >= 2, (
+            f'{ALL_PRICING_VARIANTS_ACTOR} tiered PPD entry has all-identical prices ({distinct_prices}); '
+            'tiers should differ.'
+        )
+
+
+async def test_actor_get_parses_tiered_pay_per_event(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test that actor.get() parses PAY_PER_EVENT events with eventTieredPricingUsd,
+    isPrimaryEvent and isOneTimeEvent.
+
+    Tiered PPE events use `eventTieredPricingUsd` instead of `eventPriceUsd`, plus the
+    `isPrimaryEvent` / `isOneTimeEvent` flags.
+    """
+    actor = await maybe_await(client.actor(ALL_PRICING_VARIANTS_ACTOR).get())
+    assert isinstance(actor, Actor)
+    assert actor.pricing_infos
+
+    tiered_ppe_events: list[ActorChargeEvent] = []
+    for info in actor.pricing_infos:
+        if not isinstance(info, PayPerEventActorPricingInfo):
+            continue
+        events = info.pricing_per_event.actor_charge_events or {}
+        tiered_ppe_events.extend(event for event in events.values() if event.event_tiered_pricing_usd is not None)
+
+    assert tiered_ppe_events, (
+        f'{ALL_PRICING_VARIANTS_ACTOR} should have at least one tiered PAY_PER_EVENT event — '
+        'pick a different actor if pricing changed.'
+    )
+    # Because every model uses `extra='allow'`, a regenerator that drops either alias would
+    # silently absorb the JSON key into `model_extra`. Asserting the typed attribute is
+    # populated catches that drift.
+    assert any(event.is_primary_event is True for event in tiered_ppe_events), (
+        f'{ALL_PRICING_VARIANTS_ACTOR}: no tiered PPE event has is_primary_event == True. '
+        'The isPrimaryEvent alias may have been dropped from the model.'
+    )
+    assert any(event.is_one_time_event is not None for event in tiered_ppe_events), (
+        f'{ALL_PRICING_VARIANTS_ACTOR}: no tiered PPE event has is_one_time_event populated. '
+        'The isOneTimeEvent alias may have been dropped from the model.'
+    )
+
+
+async def test_actor_pricing_infos_includes_expected_variants(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test that actor.get() parses pricing_infos for PPE, PPD and FLAT_PRICE_PER_MONTH variants.
+
+    Fixture sanity check. If the actor stops publishing one of these variants, the sibling
+    tiered_* tests no longer exercise their respective code paths and this test fails loudly —
+    pointing maintainers to pick a different fixture.
+    """
+    actor = await maybe_await(client.actor(ALL_PRICING_VARIANTS_ACTOR).get())
+    assert isinstance(actor, Actor)
+    assert actor.pricing_infos
+
+    seen = {type(entry) for entry in actor.pricing_infos}
+    expected = {
+        PayPerEventActorPricingInfo,
+        PricePerDatasetItemActorPricingInfo,
+        FlatPricePerMonthActorPricingInfo,
+    }
+    missing = expected - seen
+    assert not missing, (
+        f'{ALL_PRICING_VARIANTS_ACTOR} no longer carries pricing_infos for {missing}; pick a different fixture.'
+    )

tests/integration/test_build.py

@@ -8,14 +8,41 @@
 
 from ._utils import get_random_resource_name, maybe_await
 from apify_client._models import Actor, Build, BuildShort, ListOfBuilds
-from apify_client._resource_clients import BuildClient, BuildClientAsync
 
 if TYPE_CHECKING:
     from apify_client import ApifyClient, ApifyClientAsync
 
 # Use a public actor that has builds available
 HELLO_WORLD_ACTOR = 'apify/hello-world'
 
+# Apify-owned actor whose `latest` build sets `minMemoryMbytes: 128` (well below the spec's
+# previously-required minimum of 256). Also publishes `actorDefinition.version: "0.0.1"`,
+# exercising the semver-triplet version pattern.
+SMALL_MIN_MEMORY_ACTOR = 'apify/instagram-profile-scraper'
+
+# Apify-owned actor whose builds list includes entries with `meta.origin: "CI"`
+# from the internal CI pipeline. A deep `desc=True` pagination is needed because
+# CI builds are infrequent and rotate out of the most-recent window.
+CI_ORIGIN_ACTOR = 'apify/cheerio-scraper'
+
+
+def _pick_build_id(actor: Actor) -> str:
+    """Return a stable `build_id` from `actor.tagged_builds`, preferring the `latest` tag.
+
+    Avoids relying on API-side dict ordering (`next(iter(...))` would otherwise pick
+    whichever tag the API decides to serialize first).
+    """
+    assert actor.tagged_builds, f'{actor.username}/{actor.name} has no tagged builds'
+    latest = actor.tagged_builds.get('latest')
+    if latest is not None and latest.build_id is not None:
+        return latest.build_id
+    fallback = next(
+        (info.build_id for info in actor.tagged_builds.values() if info and info.build_id),
+        None,
+    )
+    assert fallback is not None, f'{actor.username}/{actor.name} has no tagged build with a build_id'
+    return fallback
+
 
 async def test_build_list_for_actor(client: ApifyClient | ApifyClientAsync) -> None:
     """Test listing builds for a public Actor."""
@@ -190,25 +217,71 @@ async def test_build_delete_and_abort(client: ApifyClient | ApifyClientAsync) ->
         await maybe_await(actor_client.delete())
 
 
-async def test_default_build_with_semver_version(client: ApifyClient | ApifyClientAsync) -> None:
-    """Regression test for apify/apify-client-python#811.
+async def test_build_get_accepts_small_min_memory_mbytes(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test that build.get() parses actorDefinition.minMemoryMbytes values below 256 MB.
 
-    `apify/facebook-pages-scraper` declares its actor version as `0.0.1`, a three-segment
-    SemVer string. The earlier OpenAPI pattern `^[0-9]+\\.[0-9]+$` rejected anything beyond
-    two segments, so simply fetching the default build raised a Pydantic validation error.
+    The platform's real minimum is 128 MB and many community actors use exactly that.
+    The symmetric `maxMemoryMbytes < 256` case has no stable fixture, so the `max` side
+    is implicitly trusted to share fate with `min`.
     """
-    actor = client.actor('apify/facebook-pages-scraper')
-    build_client = await maybe_await(actor.default_build())
-    assert isinstance(build_client, BuildClient | BuildClientAsync)
-    build = await maybe_await(build_client.get())
+    actor = await maybe_await(client.actor(SMALL_MIN_MEMORY_ACTOR).get())
+    assert isinstance(actor, Actor)
+    build_id = _pick_build_id(actor)
+
+    build = await maybe_await(client.build(build_id).get())
+    assert isinstance(build, Build)
+    assert build.actor_definition is not None, 'expected actorDefinition on a SUCCEEDED build'
+
+    # Fixture-drift guard: only meaningful if the chosen build actually carries a value
+    # below the old 256 threshold.
+    actual_min = build.actor_definition.min_memory_mbytes
+    assert actual_min is not None
+    assert actual_min < 256, (
+        f'{SMALL_MIN_MEMORY_ACTOR} latest build has min_memory_mbytes={actual_min!r} '
+        '(expected <256). Pick a different fixture to keep this test meaningful.'
+    )
+
+
+async def test_actor_builds_list_accepts_ci_origin(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test that actor.builds().list() parses builds with meta.origin == 'CI'.
+
+    Apify-owned actors are routinely rebuilt by the internal CI pipeline. A deep `desc=True`
+    page (limit=100) is required because CI builds are rare relative to WEB/CLI builds.
+    """
+    builds = await maybe_await(client.actor(CI_ORIGIN_ACTOR).builds().list(limit=100, desc=True))
+    assert isinstance(builds, ListOfBuilds)
+    assert builds.items, f'{CI_ORIGIN_ACTOR} should have builds'
+
+    # Fixture-drift guard: only meaningful if the page actually contains a CI-origin build.
+    # Pydantic already validated every `meta.origin` against `RunOrigin` at deserialization,
+    # so the check is exercised iff at least one such entry exists.
+    ci_origin_builds = [b for b in builds.items if b.meta is not None and b.meta.origin == 'CI']
+    assert ci_origin_builds, (
+        f'{CI_ORIGIN_ACTOR}: no builds with meta.origin == "CI" in the most-recent 100. '
+        'CI builds may have rotated out of the window — pick a different actor or paginate deeper.'
+    )
+
+
+async def test_actor_definition_version_accepts_semver_triplet(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test that ActorDefinition.version accepts semver-triplet strings like '0.0.1'.
+
+    `apify/instagram-profile-scraper` publishes its actor.json with `version: "0.0.1"`.
+    """
+    actor = await maybe_await(client.actor(SMALL_MIN_MEMORY_ACTOR).get())
+    assert isinstance(actor, Actor)
+    build_id = _pick_build_id(actor)
+
+    build = await maybe_await(client.build(build_id).get())
     assert isinstance(build, Build)
     assert build.actor_definition is not None
-    assert build.actor_definition.version is not None
-    # The fix must accept any multi-segment dot-separated numeric version
-    # (e.g. "0.1", "1.0", "0.0.1").
-    segments = build.actor_definition.version.split('.')
-    assert len(segments) >= 2
-    assert all(seg.isdigit() for seg in segments)
+    # Fixture-drift guard: only meaningful if the chosen build's version actually carries
+    # more than one dot.
+    version = build.actor_definition.version
+    assert version is not None
+    assert version.count('.') >= 2, (
+        f'{SMALL_MIN_MEMORY_ACTOR} no longer publishes a multi-dot version (got {version!r}) — '
+        'pick a different fixture to keep this test meaningful.'
+    )
 
 
 async def test_build_get_open_api_definition(client: ApifyClient | ApifyClientAsync) -> None: