tests/test_dataset_first_builders.py

"""Fast regression checks for dataset-first generation.

These tests do not call Snowflake or ThoughtSpot. They validate that the
dataset-first builders produce coherent table bundles and relationship-bearing
DDL before the slower browser quality suite runs against the test Space.
"""

from demoprep_app.dataset.generators.retail_sales import RetailSalesDatasetGenerator
from demoprep_app.scenario.extractor import ExtractedScenario
from demoprep_app.pipeline import dataset_first
from demoprep_app.pipeline.dataset_first import build_dataset_first_demo, infer_scenario_type
from demoprep_app.dataset.quality import validate_dataset_quality
from demoprep_app.scenario.contract import DimensionSpec, ScenarioContract
from demoprep_app.scenario.families import SCENARIO_FAMILIES


def test_saas_sales_specialized_builder_has_expected_shape():
    build = build_dataset_first_demo(
        company_name="Datadog",
        company_url="https://datadog.com",
        use_case="Software as a Service Sales",
        vertical="Technology",
        function="Sales",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "saas_sales"
    assert [table.name for table in build.dataset.tables] == [
        "MONTHS",
        "ACCOUNTS",
        "PRODUCTS",
        "SALES_REPS",
        "SALES_PIPELINE",
    ]
    assert build.ddl.count("CREATE TABLE") == 5
    assert build.ddl.count("FOREIGN KEY") == 4

    pipeline = build.dataset.table_map()["SALES_PIPELINE"]
    sample = pipeline.rows[:25]
    assert sample
    for row in sample:
        assert 0 <= row["PROBABILITY_PCT"] <= 100
        assert row["EXPECTED_ARR_USD"] == round(row["PIPELINE_AMOUNT_USD"] * row["PROBABILITY_PCT"] / 100.0, 2)
        if row["SALES_STAGE"] == "Closed Won":
            assert row["WON_ARR_USD"] == row["PIPELINE_AMOUNT_USD"]
            assert row["LOST_ARR_USD"] == 0.0
        if row["SALES_STAGE"] == "Closed Lost":
            assert row["LOST_ARR_USD"] == row["PIPELINE_AMOUNT_USD"]
            assert row["WON_ARR_USD"] == 0.0


def test_all_scenario_families_generate_relationship_ddl():
    failures = []
    for scenario_type in SCENARIO_FAMILIES:
        research_context = ""
        if scenario_type == "retail_sales":
            research_context = (
                "Retail sales products include running shoes, basketball shoes, training apparel, "
                "hoodies, shorts, jerseys, sneakers, backpacks, and performance socks. "
                "Channels include retail stores, online, mobile app, outlet, and retail partners."
            )
        build = build_dataset_first_demo(
            company_name="Acme",
            company_url="https://example.com",
            use_case=scenario_type.replace("_", " "),
            vertical="",
            function="",
            row_count_guidance=25,
            research_context=research_context,
        )
        if build is None:
            failures.append(f"{scenario_type}: no build")
            continue

        fact_tables = [table for table in build.dataset.tables if table.is_fact]
        expected_fk_count = max(0, len(build.dataset.tables) - 2)
        actual_fk_count = build.ddl.count("FOREIGN KEY")
        if not fact_tables:
            failures.append(f"{scenario_type}: no fact table")
        if build.ddl.count("CREATE TABLE") != len(build.dataset.tables):
            failures.append(f"{scenario_type}: DDL table count mismatch")
        if actual_fk_count < expected_fk_count:
            failures.append(f"{scenario_type}: only {actual_fk_count} foreign keys, expected at least {expected_fk_count}")

    assert not failures, "\n".join(failures)


def test_custom_dataset_first_refuses_weak_fallback_when_llm_contract_required(monkeypatch):
    def fake_extract_dataset_scenario(**kwargs):
        return ExtractedScenario(
            scenario_type="professional_services_engagements",
            business_domain="professional services engagements",
            fact_grain="client-service-line-sector-month",
            confidence=0.55,
            source="fallback",
            constraints=["LLM extraction failed: ConnectionError: connection failed"],
        )

    monkeypatch.setattr(dataset_first, "extract_dataset_scenario", fake_extract_dataset_scenario)

    try:
        build_dataset_first_demo(
            company_name="Accenture",
            company_url="https://accenture.com",
            use_case="Demo analytics for Accenture's technology and management consulting business.",
            vertical="* CUSTOM *",
            function="",
            row_count_guidance=100,
            use_llm_contract=True,
        )
    except ValueError as exc:
        message = str(exc)
    else:
        raise AssertionError("Expected weak fallback contract to be refused")

    assert "AI dataset contract unavailable" in message
    assert "Refusing weak fallback contract" in message


def test_custom_sports_venue_without_explicit_tables_does_not_use_canned_template():
    use_case = (
        "A live entertainment arena needs analytics across its basketball teams, "
        "Downtown Center, Uptown Theater, concerts, fan demographics, ticket tiers, "
        "attendance, suites, sponsorships, and email marketing channel. Include "
        "Team Alpha and Team Beta as teams."
    )
    build = build_dataset_first_demo(
        company_name="Example Arena Group",
        company_url="https://example.com",
        use_case=use_case,
        vertical="* CUSTOM *",
        function=None,
        row_count_guidance=100,
    )

    assert build is None


def test_custom_professional_services_without_explicit_tables_does_not_use_canned_template():
    use_case = (
        "Build a professional services demo for EY's assurance and consulting lines. "
        "Track billable hours vs. budget, revenue per sector, staff pyramid health, "
        "and cross-sell rate from audit to advisory. KPIs: realized rate, "
        "engagement margin, repeat client revenue %."
    )
    build = build_dataset_first_demo(
        company_name="EY US",
        company_url="https://ey.com",
        use_case=use_case,
        vertical="* CUSTOM *",
        function=None,
        row_count_guidance=100,
    )

    assert build is None


def test_quality_pool_domains_do_not_fall_back_to_generic_templates():
    cases = [
        ("FedEx", "fedex.com", "Transportation & Logistics", "Shipping", "Sales", "shipping_sales", "SHIPMENT_SALES", {"SHIPMENTS", "NET_REVENUE_USD", "ON_TIME_RATE_PCT"}),
        ("Stellantis", "stellantis.com", "Manufacturing", "Automotive", "Sales", "automotive_sales", "VEHICLE_SALES", {"VEHICLES_SOLD", "INCENTIVE_SPEND_USD", "DAYS_SUPPLY"}),
        ("Marriott", "marriott.com", "Travel & Hospitality", "Hotels", "Finance", "hotel_finance", "HOTEL_FINANCIALS", {"OCCUPANCY_PCT", "ADR_USD", "REVPAR_USD"}),
        ("PVH", "pvh.com", "Retail & Consumer Goods", "Fashion/Apparel", "Marketing", "apparel_marketing", "APPAREL_MARKETING", {"MARKDOWN_USD", "ROAS", "RETURN_RATE_PCT"}),
    ]

    for company, url, vertical, line, function, scenario_type, fact_table, expected_columns in cases:
        build = build_dataset_first_demo(
            company_name=company,
            company_url=f"https://{url}",
            use_case=f"{line} {function}",
            vertical=vertical,
            function=function,
            row_count_guidance=100,
        )

        assert build is not None
        assert build.scenario.scenario_type == scenario_type
        table = build.dataset.table_map()[fact_table]
        column_names = {column.name for column in table.columns}
        assert expected_columns <= column_names


def test_shipping_sales_dimensions_are_demo_safe_and_not_numbered_placeholders():
    build = build_dataset_first_demo(
        company_name="Echo Global",
        company_url="https://echo.com",
        use_case="Shipping Sales",
        vertical="Transportation & Logistics",
        function="Sales",
        row_count_guidance=100,
    )

    assert build is not None
    table_map = build.dataset.table_map()
    for table_name, column_name in [
        ("ACCOUNTS", "ACCOUNT_NAME"),
        ("SERVICES", "SERVICE_NAME"),
        ("ROUTES", "ROUTE_NAME"),
        ("SALES_REPS", "SALES_REP_NAME"),
    ]:
        values = [row[column_name] for row in table_map[table_name].rows]
        assert values
        assert not any(" 0" in value or value.endswith(tuple(str(i).zfill(2) for i in range(1, 40))) for value in values)
        assert not any("Sales Rep " in value or "Account " in value or "Service " in value or "Route " in value for value in values)

    assert validate_dataset_quality(build.dataset).ok


def test_retail_sales_store_names_are_demo_safe_and_not_numbered_placeholders():
    build = build_dataset_first_demo(
        company_name="Nike",
        company_url="https://nike.com",
        use_case="Retail Sales",
        vertical="Retail & Consumer Goods",
        function="Sales",
        row_count_guidance=100,
        research_context=(
            "Nike retail sales products include running shoes, basketball shoes, training shoes, "
            "Dri-FIT performance apparel, hoodies, shorts, jerseys, sneakers, backpacks, and performance socks."
        ),
    )

    assert build is not None
    table_map = build.dataset.table_map()
    values = [row["STORE_NAME"] for row in table_map["STORES"].rows]

    assert len(values) == 36
    assert "Nike Fifth Avenue Flagship" in values
    assert not any(value.endswith(tuple(str(i).zfill(2) for i in range(1, 40))) for value in values)
    assert not any(" Metro " in value or " Outlet " in value for value in values)
    assert validate_dataset_quality(build.dataset).ok


def test_retail_product_expansion_uses_named_variants_not_numbered_placeholders():
    scenario = ScenarioContract(
        company_name="Sonos",
        company_url="https://sonos.com",
        use_case="Consumer Electronics Sales",
        scenario_type="retail_sales",
        fact_grain="store-product-channel-day",
        dimensions=[
            DimensionSpec(name="PRODUCTS", semantic_role="product", values=["Soundbars", "Speakers", "Accessories", "Streaming"]),
        ],
        metadata={"seed": 123},
    )

    dataset = RetailSalesDatasetGenerator().generate(scenario, row_count=100)
    values = [row["PRODUCT_NAME"] for row in dataset.table_map()["PRODUCTS"].rows]

    assert len(values) == 36
    assert not any("Variant " in value for value in values)
    assert not any(value.endswith(tuple(str(i).zfill(2) for i in range(1, 40))) for value in values)
    assert validate_dataset_quality(dataset).ok


def test_retail_contract_uses_researched_products_before_generation():
    build = build_dataset_first_demo(
        company_name="Nike",
        company_url="https://nike.com",
        use_case="Retail Sales",
        vertical="Retail & Consumer Goods",
        function="Sales",
        row_count_guidance=100,
        research_context=(
            "Nike retail sales demo products include running shoes, basketball shoes, "
            "training shoes, soccer boots, Dri-FIT performance apparel, hoodies, shorts, and jerseys. "
            "Channels include Nike stores, Nike.com, mobile app, outlet, and retail partners."
        ),
    )

    assert build is not None
    table_map = build.dataset.table_map()
    products = [row["PRODUCT_NAME"] for row in table_map["PRODUCTS"].rows]
    product_prices = [row["LIST_PRICE"] for row in table_map["PRODUCTS"].rows]
    channels = {row["CHANNEL"] for row in table_map["SALES_FACT"].rows}
    fact_columns = {column.name for column in table_map["SALES_FACT"].columns}

    assert "Running Shoes" in products
    assert "Basketball Shoes" in products
    assert "Dri-FIT" in products
    assert "Streaming Platform" not in channels
    assert "Promotional Offer" not in channels
    assert "ACTIVE_ACCOUNTS" not in fact_columns
    assert "PLATFORM_USAGE_HOURS" not in fact_columns
    assert min(product_prices) >= 18
    assert max(product_prices) <= 219
    assert build.scenario.metadata["company_contract_sources"]["PRODUCTS"] == "fallback"
    assert validate_dataset_quality(build.dataset).ok


def test_retail_contract_blocks_incompatible_research_terms_before_generation():
    try:
        build_dataset_first_demo(
            company_name="Nike",
            company_url="https://nike.com",
            use_case="Fashion/Apparel Sales",
            vertical="Retail & Consumer Goods",
            function="Sales",
            row_count_guidance=100,
            research_context="Bad extracted terms should not drive products: soundbars, streaming, smart tv.",
        )
    except ValueError as exc:
        message = str(exc)
    else:
        raise AssertionError("Expected company contract failure")

    assert "Company data contract failed" in message
    assert "incompatible product terms" in message


def test_retail_contract_repairs_thin_research_instead_of_failing_run():
    build = build_dataset_first_demo(
        company_name="Nike",
        company_url="https://nike.com",
        use_case="Retail Sales",
        vertical="Retail & Consumer Goods",
        function="Sales",
        row_count_guidance=100,
        research_context=None,
    )

    assert build is not None
    table_map = build.dataset.table_map()
    products = [row["PRODUCT_NAME"] for row in table_map["PRODUCTS"].rows]
    channels = {row["CHANNEL"] for row in table_map["SALES_FACT"].rows}
    warnings = build.scenario.metadata["company_contract_warnings"]

    assert any("too few researched" in warning for warning in warnings)
    assert len(products) == 36
    assert any("Shoe" in product or "Sneaker" in product or "Runner" in product for product in products)
    assert "Streaming Platform" not in channels
    assert validate_dataset_quality(build.dataset).ok


def test_sonos_retail_contract_allows_consumer_electronics_products():
    build = build_dataset_first_demo(
        company_name="Sonos",
        company_url="https://sonos.com",
        use_case="Consumer Electronics Sales",
        vertical="Retail & Consumer Goods",
        function="Sales",
        row_count_guidance=100,
        research_context="Sonos sells speakers, soundbars, portable audio, home theater, and accessories.",
    )

    assert build is not None
    products = [row["PRODUCT_NAME"] for row in build.dataset.table_map()["PRODUCTS"].rows]

    assert "Soundbars" in products
    assert "Speakers" in products
    assert build.scenario.metadata["company_contract_sources"]["PRODUCTS"] == "fallback"
    assert validate_dataset_quality(build.dataset).ok


def test_transportation_function_routing_keeps_sales_and_finance_distinct():
    cases = [
        ("Shipping", "Sales", "shipping_sales"),
        ("Shipping", "Marketing", "marketing_funnel"),
        ("Shipping", "HR", "workforce_hr"),
        ("Shipping", "IT", "it_operations"),
        ("Shipping", "Legal", "legal_matter_management"),
        ("Trucking", "Sales", "sales_pipeline"),
        ("Trucking", "Marketing", "marketing_funnel"),
        ("Trucking", "Finance", "trucking_finance"),
        ("Trucking", "HR", "workforce_hr"),
        ("Trucking", "IT", "it_operations"),
        ("Trucking", "Legal", "legal_matter_management"),
        ("Air Transport", "Sales", "airline_route_operations"),
        ("Air Transport", "Finance", "airline_finance"),
        ("Air Transport", "HR", "workforce_hr"),
        ("Air Transport", "Legal", "legal_matter_management"),
    ]

    for line, function, expected in cases:
        assert infer_scenario_type(
            use_case=f"{line} {function}",
            vertical="Transportation & Logistics",
            function=function,
        ) == expected


def test_trucking_sales_does_not_route_to_trucking_finance():
    build = build_dataset_first_demo(
        company_name="Linxup",
        company_url="https://www.linxup.com/",
        use_case="Trucking Sales",
        vertical="Transportation & Logistics",
        function="Sales",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "sales_pipeline"
    assert "SALES_PIPELINE" in build.dataset.table_map()
    assert "TRUCKING_FINANCIALS" not in build.dataset.table_map()


def test_ad_yield_arpu_routes_to_ad_monetization_not_sales_pipeline():
    build = build_dataset_first_demo(
        company_name="Vizio",
        company_url="https://www.vizio.com/",
        use_case=(
            "Focus on Ad yield and ARPU, optimizing revenue through SmartCast users "
            "across CTV placements, FAST channels, ad requests, eCPM, fill rate, "
            "completion rate, watch time, and audience cohorts."
        ),
        vertical="Media & Entertainment",
        function="Revenue",
        row_count_guidance=100,
        use_llm_contract=True,
    )

    assert build is not None
    assert build.scenario.scenario_type == "ad_monetization"
    table_map = build.dataset.table_map()
    assert "AD_MONETIZATION" in table_map
    assert "SALES_PIPELINE" not in table_map
    fact_columns = {column.name for column in table_map["AD_MONETIZATION"].columns}
    assert {
        "AD_REVENUE_USD",
        "ARPU_USD",
        "ECPM_USD",
        "FILL_RATE_PCT",
        "AD_YIELD_PER_WATCH_HOUR_USD",
        "REVENUE_LEAKAGE_USD",
    }.issubset(fact_columns)
    assert validate_dataset_quality(build.dataset).ok


def test_grocery_finance_routes_to_cpg_financials_not_sales_fact():
    build = build_dataset_first_demo(
        company_name="General Mills",
        company_url="https://generalmills.com",
        use_case="Grocery Finance",
        vertical="Retail & Consumer Goods",
        function="Finance",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "cpg_finance"
    table_map = build.dataset.table_map()
    assert "CPG_FINANCIALS" in table_map
    assert "SALES_FACT" not in table_map
    fact_columns = {column.name for column in table_map["CPG_FINANCIALS"].columns}
    assert {
        "CASES_SHIPPED",
        "TRADE_SPEND_USD",
        "NET_SALES_USD",
        "COGS_USD",
        "FREIGHT_COST_USD",
        "GROSS_MARGIN_USD",
        "FORECAST_VARIANCE_PCT",
    } <= fact_columns
    assert "CAC_USD" not in fact_columns
    assert "LTV_USD" not in fact_columns


def test_baker_hughes_chart_post_merger_keywords_do_not_trigger_nine_table_template():
    use_case = (
        "Baker Hughes acquired Chart Industries and needs a post-merger integration "
        "demo for supplier spend consolidation, aftermarket attach rate on Chart's "
        "installed base, cross-selling, customer invoicing, AR aging, DSO, and cash flow."
    )
    build = build_dataset_first_demo(
        company_name="Baker Hughes + Chart Industries",
        company_url="https://www.bakerhughes.com",
        use_case=use_case,
        vertical="* CUSTOM *",
        function=None,
        row_count_guidance=200,
    )

    assert build is None


def test_explicit_table_prompt_overrides_post_merger_template_for_ar_aging():
    use_case = """
Customer Invoicing & AR Aging
Generate synthetic accounts receivable and invoicing data for a Baker Hughes + Chart Industries cash flow demo.
The request is intentionally scoped to the following tables only.

Tables

dim_customer (~200 rows)
Customer ID, customer name, industry, country, region, customer tier, legacy org, contracted payment terms.

dim_invoice_category (~20 rows)
Category ID, category name, business unit, order type.

fact_invoices (~25,000 rows, Jan 2025 - Jun 2026)
Invoice ID, invoice date, due date, customer ID, invoice category ID, invoice amount USD,
payment received date, amount paid USD, dispute flag, dispute reason, collector assigned, legacy org.

Anomalies to Seed
APAC and Middle East Chart customers averaging 75-90 days to pay vs BKR benchmark of 45 days.
Large LNG project invoices sitting 60-90 days overdue.
"""
    build = build_dataset_first_demo(
        company_name="Baker Hughes + Chart Industries",
        company_url="https://www.bakerhughes.com",
        use_case=use_case,
        vertical="* CUSTOM *",
        function=None,
        row_count_guidance=1000,
    )

    assert build is not None
    assert build.scenario.scenario_type == "explicit_table_contract"
    assert [table.name for table in build.dataset.tables] == [
        "DIM_CUSTOMER",
        "DIM_INVOICE_CATEGORY",
        "FACT_INVOICES",
    ]
    assert build.ddl.count("CREATE TABLE") == 3
    assert build.ddl.count("FOREIGN KEY") >= 2

    tables = build.dataset.table_map()
    assert len(tables["DIM_CUSTOMER"].rows) == 200
    assert len(tables["DIM_INVOICE_CATEGORY"].rows) == 20
    assert len(tables["FACT_INVOICES"].rows) == 1000
    assert {"DAYS_OUTSTANDING", "AGING_BUCKET", "PAST_DUE_AMOUNT_USD"} <= {
        column.name for column in tables["FACT_INVOICES"].columns
    }
    assert any(row["AGING_BUCKET"] in {"60-90 Days", "90+ Days"} for row in tables["FACT_INVOICES"].rows)


def test_saas_finance_routes_to_subscription_revenue_not_generic_unit_economics():
    build = build_dataset_first_demo(
        company_name="NetSuite",
        company_url="https://netsuite.com",
        use_case="SaaS Finance",
        vertical="Technology",
        function="Finance",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "subscription_revenue"
    table_map = build.dataset.table_map()
    assert "SUBSCRIPTION_REVENUE" in table_map
    assert "UNIT_ECONOMICS" not in table_map
    fact_columns = {column.name for column in table_map["SUBSCRIPTION_REVENUE"].columns}
    assert {
        "STARTING_ARR_USD",
        "NEW_LOGO_ARR_USD",
        "EXPANSION_ARR_USD",
        "CONTRACTION_ARR_USD",
        "CHURNED_ARR_USD",
        "ENDING_ARR_USD",
        "MRR_USD",
        "NRR_PCT",
    } <= fact_columns
    assert validate_dataset_quality(build.dataset).ok


def test_hotel_and_trucking_finance_pass_domain_quality_contracts():
    cases = [
        ("Wyndham", "https://wyndham.com", "Hotel Finance", "Travel & Hospitality", "Finance", "hotel_finance"),
        ("J.B. Hunt", "https://jbhunt.com", "Trucking Finance", "Transportation & Logistics", "Finance", "trucking_finance"),
    ]

    for company, url, use_case, vertical, function, scenario_type in cases:
        build = build_dataset_first_demo(
            company_name=company,
            company_url=url,
            use_case=use_case,
            vertical=vertical,
            function=function,
            row_count_guidance=100,
        )

        assert build is not None
        assert build.scenario.scenario_type == scenario_type
        assert validate_dataset_quality(build.dataset).ok


def test_automotive_supplier_sales_routes_to_supplier_programs():
    build = build_dataset_first_demo(
        company_name="BorgWarner",
        company_url="https://borgwarner.com",
        use_case="Automotive Sales",
        vertical="Manufacturing",
        function="Sales",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "automotive_supplier_sales"
    table_map = build.dataset.table_map()
    assert "SUPPLIER_PROGRAM_SALES" in table_map
    assert "VEHICLE_SALES" not in table_map
    fact_columns = {column.name for column in table_map["SUPPLIER_PROGRAM_SALES"].columns}
    assert {
        "RFQS_RECEIVED",
        "QUOTED_REVENUE_USD",
        "AWARDED_REVENUE_USD",
        "BACKLOG_USD",
        "TOOLING_RECOVERY_USD",
        "WARRANTY_RESERVE_USD",
        "PROGRAM_MARGIN_USD",
        "DEFECT_PPM",
    } <= fact_columns
    assert "DEALER_HOLDBACK_USD" not in fact_columns
    assert "TEST_DRIVES" not in fact_columns


def test_vehicle_oem_sales_stays_on_automotive_sales():
    build = build_dataset_first_demo(
        company_name="Stellantis",
        company_url="https://stellantis.com",
        use_case="Automotive Sales",
        vertical="Manufacturing",
        function="Sales",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "automotive_sales"
    assert "VEHICLE_SALES" in build.dataset.table_map()


def test_function_specific_routing_overrides_industry_terms():
    cases = [
        ("Financial Services", "Banking", "HR", "workforce_hr"),
        ("Financial Services", "Banking", "Legal", "legal_matter_management"),
        ("Travel & Hospitality", "Restaurants/Catering", "Marketing", "marketing_funnel"),
        ("Technology", "Hardware", "Sales", "retail_sales"),
        ("Healthcare & Life Sciences", "Healthcare Providers", "Sales", "sales_pipeline"),
        ("Retail & Consumer Goods", "Grocery", "Finance", "cpg_finance"),
        ("Retail & Consumer Goods", "Consumer Electronics", "IT", "it_operations"),
        ("Transportation & Logistics", "Warehousing", "Sales", "inventory_supply_chain"),
        ("Transportation & Logistics", "Supply Chain", "Sales", "inventory_supply_chain"),
        ("Manufacturing", "Automotive", "Finance", "finance_unit_economics"),
        ("Manufacturing", "Electronics Manufacturing", "IT", "it_operations"),
        ("Manufacturing", "Electronics Manufacturing", "Sales", "sales_pipeline"),
        ("Travel & Hospitality", "Restaurants/Catering", "Finance", "finance_unit_economics"),
        ("Travel & Hospitality", "Travel/Tourism", "Finance", "finance_unit_economics"),
    ]

    for vertical, line, function, expected in cases:
        assert infer_scenario_type(
            use_case=f"{line} {function}",
            vertical=vertical,
            function=function,
        ) == expected


def test_it_operations_has_two_year_hourly_calendar():
    build = build_dataset_first_demo(
        company_name="Microsoft",
        company_url="https://microsoft.com",
        use_case="Software as a Service IT operations reliability",
        vertical="Technology",
        function="IT",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "it_operations"
    hours = build.dataset.table_map()["HOURS"]
    assert len(hours.rows) == 24 * 730
    assert {"MONTH_NUM", "YEAR_NUM", "QUARTER_NUM"} <= {column.name for column in hours.columns}
    fact = build.dataset.table_map()["IT_OPERATIONS"]
    assert {"P1_INCIDENTS", "IMPACTED_USERS", "ERROR_BUDGET_BURN_PCT"} <= {column.name for column in fact.columns}
    assert max(row["DOWNTIME_HOURS"] for row in fact.rows[:100]) <= 1.0
    assert max(row["INCIDENTS"] for row in fact.rows[:100]) <= 10


def test_medical_device_inventory_dimensions_are_not_numbered_fillers():
    build = build_dataset_first_demo(
        company_name="Intuitive Surgical",
        company_url="https://www.intuitive.com",
        use_case="Medical device manufacturing operations inventory and warehouse supply chain",
        vertical="Manufacturing",
        function="Operations",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "inventory_supply_chain"

    table_map = build.dataset.table_map()
    products = [row["PRODUCT_NAME"] for row in table_map["PRODUCTS"].rows]
    warehouses = [row["WAREHOUSE_NAME"] for row in table_map["WAREHOUSES"].rows]
    suppliers = [row["SUPPLIER_NAME"] for row in table_map["SUPPLIERS"].rows]
    regions = [row["REGION_NAME"] for row in table_map["REGIONS"].rows]

    assert len(products) == 36
    assert len(warehouses) == 24
    assert len(suppliers) == 24
    assert "da Vinci 5 Surgical System" in products
    assert "Sunnyvale Final Assembly" in warehouses
    assert "Precision Motion Components" in suppliers
    assert "Manufacturing Sites" in regions

    generated_names = products + warehouses + suppliers
    assert not any("Product 29" in name or "Warehouse 21" in name or "Supplier 19" in name for name in generated_names)
    assert not any(name.rsplit(" ", 1)[-1].isdigit() for name in generated_names)


def test_higher_education_enrollment_dimensions_are_not_numbered_fillers():
    build = build_dataset_first_demo(
        company_name="Wake Forest University",
        company_url="https://www.wfu.edu",
        use_case="Student Success Enrollment",
        vertical="Education",
        function="Operations",
        row_count_guidance=100,
    )

    assert build is not None
    assert build.scenario.scenario_type == "education_enrollment"

    table_map = build.dataset.table_map()
    programs = [row["PROGRAM_NAME"] for row in table_map["PROGRAMS"].rows]
    campuses = [row["CAMPUS_NAME"] for row in table_map["CAMPUSES"].rows]
    segments = [row["STUDENT_SEGMENT_NAME"] for row in table_map["STUDENT_SEGMENTS"].rows]
    terms = [row["TERM_NAME"] for row in table_map["TERMS"].rows]

    assert len(programs) == 18
    assert len(campuses) == 18
    assert len(segments) == 18
    assert len(terms) == 8
    assert "School of Business" in programs
    assert "Reynolda Campus" in campuses
    assert "First-Generation Students" in segments
    assert "Fall Early Decision I" in terms

    generated_names = programs + campuses + segments + terms
    assert not any("Program 17" in name or "Campus 18" in name or "Student Segment 14" in name or "Term 07" in name for name in generated_names)
    assert not any(name.rsplit(" ", 1)[-1].isdigit() for name in generated_names)


def test_new_quality_pool_domains_are_not_generic_finance_or_pipeline():
    cases = [
        ("J.B. Hunt", "jbhunt.com", "Transportation & Logistics", "Trucking Finance", "Finance", "trucking_finance", "TRUCKING_FINANCIALS", {"LOADS", "REVENUE_PER_LOADED_MILE_USD", "EMPTY_MILE_PCT"}),
        ("Delta Air Lines", "delta.com", "Transportation & Logistics", "Air Transport Finance", "Finance", "airline_finance", "AIRLINE_FINANCIALS", {"RASM_CENTS", "CASM_CENTS", "FUEL_COST_USD"}),
        ("Johnson & Johnson", "jnj.com", "Healthcare & Life Sciences", "Life Sciences Sales", "Sales", "life_sciences_sales", "LIFE_SCIENCES_SALES", {"REBATE_USD", "GROSS_TO_NET_DEDUCTION_PCT", "PROCEDURES_OR_SCRIPTS"}),
    ]

    for company, url, vertical, use_case, function, scenario_type, fact_table, expected_columns in cases:
        build = build_dataset_first_demo(
            company_name=company,
            company_url=f"https://{url}",
            use_case=use_case,
            vertical=vertical,
            function=function,
            row_count_guidance=100,
        )

        assert build is not None
        assert build.scenario.scenario_type == scenario_type
        table = build.dataset.table_map()[fact_table]
        assert expected_columns <= {column.name for column in table.columns}