42 - Testing Data Pipelines

# File: de-onboarding/tests/test_utils.py
from typing import Dict, Any  # For type annotations
import pytest  # For testing
import utils  # Import utils module

def test_validate_sale_valid() -> None:
    """Test valid sale validation."""
    config: Dict[str, Any] = {
        "min_price": 10.0,
        "max_quantity": 100,
        "required_fields": ["product", "price", "quantity"],
        "product_prefix": "Halal",
        "max_decimals": 2
    }
    sale: Dict[str, str] = {
        "product": "Halal Laptop",
        "price": "999.99",
        "quantity": "2"
    }
    result: bool = utils.validate_sale(sale, config)
    assert result is True, "Valid sale should pass validation"

def test_validate_sale_missing_product() -> None:
    """Test sale with missing product."""
    config: Dict[str, Any] = {
        "min_price": 10.0,
        "max_quantity": 100,
        "required_fields": ["product", "price", "quantity"],
        "product_prefix": "Halal",
        "max_decimals": 2
    }
    sale: Dict[str, str] = {
        "product": "",
        "price": "999.99",
        "quantity": "2"
    }
    result: bool = utils.validate_sale(sale, config)
    assert result is False, "Sale with missing product should fail"

# File: de-onboarding/tests/test_pipeline.py
from typing import Dict, Any  # For type annotations
import pandas as pd  # For DataFrame
import pytest  # For testing
import sales_processor  # Import pipeline module
import yaml  # For YAML parsing

@pytest.fixture
def config() -> Dict[str, Any]:
    """Fixture for config."""
    with open("data/config.yaml", "r") as file:
        return yaml.safe_load(file)

def test_pipeline_end_to_end(config: Dict[str, Any]) -> None:
    """Test end-to-end pipeline with sales.csv."""
    df, valid_sales, total_records = sales_processor.load_and_validate_sales("data/sales.csv", config)
    results, valid_count = sales_processor.process_sales(df, config)
    assert valid_sales == 3, "Should have 3 valid sales"
    assert total_records == 3, "Should process 3 records"
    assert results["total_sales"] == pytest.approx(2499.83, 0.01), "Total sales incorrect"
    assert len(results["unique_products"]) == 3, "Should have 3 unique products"

# File: de-onboarding/tests/test_database.py
from typing import Any, Dict  # For type annotations
import pytest  # For testing
from unittest.mock import patch, Mock  # For mocking
import pandas as pd  # For DataFrame
import sales_processor  # Import pipeline module

def test_load_sales_with_mock_db() -> None:
    """Test loading sales with mocked database using SQLAlchemy engine."""
    mock_df = pd.DataFrame({
        "product": ["Halal Laptop", "Halal Mouse"],
        "price": [999.99, 24.99],
        "quantity": [2, 10]
    })
    mock_engine = Mock()
    with patch("sqlalchemy.create_engine", return_value=mock_engine) as mock_create_engine:
        with patch("pandas.read_sql", return_value=mock_df) as mock_read_sql:
            df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
            assert len(df) == 2, "Should load 2 rows"
            assert df["product"].tolist() == ["Halal Laptop", "Halal Mouse"], "Incorrect products"
            mock_create_engine.assert_called_once_with("sqlite:///data/sales.db")
            mock_read_sql.assert_called_once_with("SELECT * FROM sales", mock_engine)

min_price: 10.0
max_quantity: 100
required_fields:
  - product
  - price
  - quantity
product_prefix: 'Halal'
max_decimals: 2

# File: de-onboarding/utils.py
from typing import Dict, Any  # For type annotations
import yaml  # For YAML parsing

def is_numeric(s: str, max_decimals: int = 2) -> bool:
    """Check if string is a decimal number with up to max_decimals."""
    parts = s.split(".")
    if len(parts) != 2 or not parts[0].replace("-", "").isdigit() or not parts[1].isdigit():
        return False
    return len(parts[1]) <= max_decimals

def clean_string(s: str) -> str:
    """Strip whitespace from string."""
    return s.strip()

def is_numeric_value(x: Any) -> bool:
    """Check if value is numeric."""
    return isinstance(x, (int, float))

def has_valid_decimals(x: Any, max_decimals: int) -> bool:
    """Check if value has valid decimal places."""
    return is_numeric(str(x), max_decimals)

def apply_valid_decimals(x: Any, max_decimals: int) -> bool:
    """Apply has_valid_decimals to a value."""
    return has_valid_decimals(x, max_decimals)

def is_integer(x: Any) -> bool:
    """Check if value is an integer."""
    return str(x).isdigit()

def validate_sale(sale: Dict[str, str], config: Dict[str, Any]) -> bool:
    """Validate sale based on config rules."""
    required_fields = config["required_fields"]
    min_price = config["min_price"]
    max_quantity = config["max_quantity"]
    prefix = config["product_prefix"]
    max_decimals = config["max_decimals"]

    print(f"Validating sale: {sale}")
    for field in required_fields:
        if not sale.get(field) or sale[field].strip() == "":
            print(f"Invalid sale: missing {field}: {sale}")
            return False

    product = clean_string(sale["product"])
    if not product.startswith(prefix):
        print(f"Invalid sale: product lacks '{prefix}' prefix: {sale}")
        return False

    price = clean_string(sale["price"])
    if not is_numeric(price, max_decimals) or float(price) < min_price or float(price) <= 0:
        print(f"Invalid sale: invalid price: {sale}")
        return False

    quantity = clean_string(sale["quantity"])
    if not quantity.isdigit() or int(quantity) > max_quantity:
        print(f"Invalid sale: invalid quantity: {sale}")
        return False

    return True

# File: de-onboarding/models.py
from pydantic import BaseModel, validator  # For type-safe validation
from typing import Optional  # For optional fields

class Sale(BaseModel):
    """Pydantic model for sale data."""
    product: str
    price: float
    quantity: int

    @validator("product")
    def check_product(cls, v: str) -> str:
        """Ensure product is non-empty."""
        if not v.strip():
            raise ValueError("Product cannot be empty")
        return v

    @validator("price")
    def check_price(cls, v: float) -> float:
        """Ensure price is positive."""
        if v <= 0:
            raise ValueError("Price must be positive")
        return v

    @validator("quantity")
    def check_quantity(cls, v: int) -> int:
        """Ensure quantity is positive."""
        if v <= 0:
            raise ValueError("Quantity must be positive")
        return v

# File: de-onboarding/sales_processor.py
from typing import Dict, Any, Tuple  # For type annotations
import pandas as pd  # For DataFrame operations
import numpy as np  # For numerical computations
import yaml  # For YAML parsing
import json  # For JSON export
import sqlite3  # For SQLite operations
from sqlalchemy import create_engine  # For database connection
from models import Sale  # Import Pydantic model
import utils  # Import utils module
import os  # For file existence check

def read_config(config_path: str) -> Dict[str, Any]:
    """Read YAML configuration."""
    print(f"Opening config: {config_path}")
    with open(config_path, "r") as file:
        config = yaml.safe_load(file)
    print(f"Loaded config: {config}")
    return config

def load_to_db(csv_path: str, db_path: str, table_name: str, config: Dict[str, Any]) -> None:
    """Load CSV to SQLite database after preprocessing."""
    print(f"Loading {csv_path} to {db_path}")
    df = pd.read_csv(csv_path)

    # Preprocess to filter valid rows
    df = df.dropna(subset=["product"])
    df = df[df["product"].str.startswith(config["product_prefix"])]
    df = df[df["quantity"].apply(utils.is_integer)]
    df["quantity"] = df["quantity"].astype(int)
    df = df[df["quantity"] <= config["max_quantity"]]
    df = df[df["price"].apply(utils.is_numeric_value)]
    df = df[df["price"] > 0]
    df = df[df["price"] >= config["min_price"]]
    df = df[df["price"].apply(lambda x: utils.apply_valid_decimals(x, config["max_decimals"]))]

    conn = sqlite3.connect(db_path)
    df.to_sql(table_name, conn, if_exists="replace", index=False)
    conn.close()
    print(f"Loaded {len(df)} valid rows to {db_path}")

def load_sales_from_db(db_url: str, table_name: str) -> pd.DataFrame:
    """Load sales from database."""
    print(f"Loading from {db_url}")
    engine = create_engine(db_url)
    df = pd.read_sql(f"SELECT * FROM {table_name}", engine)
    print("Loaded DataFrame:")
    print(df.head())
    return df

# Production Optimization Example (for illustration only, not executed)
# This shows a single-pass Pydantic validation, reducing complexity from O(2n) to O(n)
# def validate_sales_efficient(df: pd.DataFrame, config: Dict[str, Any]) -> pd.DataFrame:
#     """Validate sales using only Pydantic for efficiency."""
#     valid_rows = []
#     for _, row in df.iterrows():
#         try:
#             sale = Sale(product=row["product"], price=row["price"], quantity=row["quantity"])
#             if sale.product.startswith(config["product_prefix"]) and \
#                sale.quantity <= config["max_quantity"] and \
#                sale.price >= config["min_price"] and \
#                len(str(float(sale.price)).split(".")[1]) <= config["max_decimals"]:
#                 valid_rows.append(row)
#         except ValueError as e:
#             print(f"Invalid sale: {row.to_dict()}, Error: {e}")
#     return pd.DataFrame(valid_rows)

def validate_sales(df: pd.DataFrame, config: Dict[str, Any]) -> pd.DataFrame:
    """Validate sales using Pydantic and config."""
    print("Validating DataFrame:")
    print(df.head())

    # Explicitly check required columns
    required_fields = config["required_fields"]
    missing_fields = [f for f in required_fields if f not in df.columns]
    if missing_fields:
        print(f"Missing columns: {missing_fields}")
        return pd.DataFrame()

    df = df.dropna(subset=["product"])
    df = df[df["product"].str.startswith(config["product_prefix"])]
    df = df[df["quantity"].apply(lambda x: isinstance(x, (int, float)) and x.is_integer())]
    df["quantity"] = df["quantity"].astype(int)
    df = df[df["quantity"] <= config["max_quantity"]]
    df = df[df["price"].apply(lambda x: isinstance(x, (int, float)))]
    df = df[df["price"] > 0]
    df = df[df["price"] >= config["min_price"]]
    df = df[df["price"].apply(lambda x: len(str(float(x)).split(".")[1]) <= config["max_decimals"])]

    # Validate with Pydantic
    valid_rows = []
    for _, row in df.iterrows():
        try:
            sale = Sale(product=row["product"], price=row["price"], quantity=row["quantity"])
            valid_rows.append(row)
        except ValueError as e:
            print(f"Invalid sale: {row.to_dict()}, Error: {e}")

    validated_df = pd.DataFrame(valid_rows)
    print("Validated DataFrame:")
    print(validated_df)
    return validated_df

def process_sales(df: pd.DataFrame, config: Dict[str, Any]) -> Tuple[Dict[str, Any], int]:
    """Process sales: compute total and top products."""
    if df.empty:
        print("No valid sales data")
        return {"total_sales": 0.0, "unique_products": [], "top_products": {}}, 0

    df["amount"] = df["price"] * df["quantity"]
    print("DataFrame with Amount:")
    print(df)

    total_sales = np.sum(df["amount"].values)
    unique_products = df["product"].unique().tolist()
    sales_by_product = df.groupby("product")["amount"].sum()
    top_products = sales_by_product.sort_values(ascending=False).head(3).to_dict()

    valid_sales = len(df)
    print(f"Valid sales: {valid_sales} records")

    return {
        "total_sales": float(total_sales),
        "unique_products": unique_products,
        "top_products": top_products
    }, valid_sales

def export_results(results: Dict[str, Any], json_path: str) -> None:
    """Export results to JSON."""
    print(f"Writing to: {json_path}")
    with open(json_path, "w") as file:
        json.dump(results, file, indent=2)
    print(f"Exported results to {json_path}")

def load_and_validate_sales(csv_path: str, config: Dict[str, Any]) -> Tuple[pd.DataFrame, int, int]:
    """Load and validate sales CSV."""
    print(f"Loading CSV: {csv_path}")
    df = pd.read_csv(csv_path)
    print("Initial DataFrame:")
    print(df.head())

    required_fields = config["required_fields"]
    missing_fields = [f for f in required_fields if f not in df.columns]
    if missing_fields:
        print(f"Missing columns: {missing_fields}")
        return pd.DataFrame(), 0, len(df)

    df = validate_sales(df, config)
    total_records = len(df)
    print("Validated DataFrame:")
    print(df)
    return df, len(df), total_records

def main() -> None:
    """Main function to process sales data."""
    csv_path = "data/sales.csv"
    config_path = "data/config.yaml"
    db_path = "data/sales.db"
    json_path = "data/sales_results.json"
    table_name = "sales"

    config = read_config(config_path)
    load_to_db(csv_path, db_path, table_name, config)
    df = load_sales_from_db(f"sqlite:///{db_path}", table_name)
    validated_df = validate_sales(df, config)
    results, valid_sales = process_sales(validated_df, config)
    export_results(results, json_path)

    print("\nSales Report:")
    print(f"Valid Sales: {valid_sales}")
    print(f"Total Sales: ${round(results['total_sales'], 2)}")
    print(f"Unique Products: {results['unique_products']}")
    print(f"Top Products: {results['top_products']}")
    print("Processing completed")

if __name__ == "__main__":
    main()

# File: de-onboarding/sales_api.py
from typing import Dict, Any  # For type annotations
import requests  # For HTTP requests

def fetch_sales_data(api_url: str) -> Dict[str, Any]:
    """Fetch sales data from an API endpoint."""
    response = requests.get(api_url)
    return response.json()

# File: de-onboarding/tests/test_sales_processor.py
from typing import Dict, Any, Tuple  # For type annotations
import pandas as pd  # For DataFrame
import pytest  # For testing
from unittest.mock import patch, Mock  # For mocking
import sales_processor  # Import pipeline module
import yaml  # For YAML parsing
import os  # For file operations

@pytest.fixture
def config() -> Dict[str, Any]:
    """Fixture for config."""
    with open("data/config.yaml", "r") as file:
        return yaml.safe_load(file)

@pytest.fixture
def sample_df() -> pd.DataFrame:
    """Fixture for sample DataFrame."""
    return pd.DataFrame({
        "product": ["Halal Laptop", "Halal Mouse", "Non-Halal"],
        "price": [999.99, 24.99, 10.0],
        "quantity": [2, 10, 5]
    })

def test_validate_sales(config: Dict[str, Any], sample_df: pd.DataFrame) -> None:
    """Test sales validation."""
    validated_df = sales_processor.validate_sales(sample_df, config)
    assert len(validated_df) == 2, "Should validate 2 rows"
    assert all(validated_df["product"].str.startswith("Halal")), "All products should be Halal"
    assert all(validated_df["quantity"] <= config["max_quantity"]), "Quantities should be within limit"

def test_validate_sales_invalid_columns(config: Dict[str, Any]) -> None:
    """Test validation with incorrect columns."""
    invalid_df = pd.DataFrame({
        "name": ["Halal Laptop"],
        "price": [999.99],
        "quantity": [2]
    })
    validated_df = sales_processor.validate_sales(invalid_df, config)
    assert validated_df.empty, "Should return empty DataFrame for missing required columns"

def test_process_sales(config: Dict[str, Any], sample_df: pd.DataFrame) -> None:
    """Test sales processing."""
    validated_df = sample_df.iloc[:2]  # Only Halal products
    results, valid_sales = sales_processor.process_sales(validated_df, config)
    assert valid_sales == 2, "Should have 2 valid sales"
    assert results["total_sales"] == pytest.approx(2249.88, 0.01), "Total sales incorrect"
    assert len(results["unique_products"]) == 2, "Should have 2 unique products"

def test_pipeline_integration(config: Dict[str, Any]) -> None:
    """Test end-to-end pipeline."""
    sales_processor.load_to_db("data/sales.csv", "data/sales.db", "sales", config)
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    validated_df = sales_processor.validate_sales(df, config)
    results, valid_sales = sales_processor.process_sales(validated_df, config)
    assert valid_sales == 3, "Should have 3 valid sales"
    assert results["total_sales"] == pytest.approx(2499.83, 0.01), "Total sales incorrect"

@patch("sqlalchemy.create_engine")
@patch("pandas.read_sql")
def test_load_sales_mock_db(mock_read_sql: Mock, mock_create_engine: Mock) -> None:
    """Test loading sales with mocked database."""
    mock_df = pd.DataFrame({
        "product": ["Halal Laptop", "Halal Mouse"],
        "price": [999.99, 24.99],
        "quantity": [2, 10]
    })
    mock_engine = Mock()
    mock_create_engine.return_value = mock_engine
    mock_read_sql.return_value = mock_df
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    assert len(df) == 2, "Should load 2 rows"
    mock_create_engine.assert_called_once_with("sqlite:///data/sales.db")
    mock_read_sql.assert_called_once_with("SELECT * FROM sales", mock_engine)

def test_empty_csv(config: Dict[str, Any]) -> None:
    """Test pipeline with empty CSV."""
    sales_processor.load_to_db("data/empty.csv", "data/sales.db", "sales", config)
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    validated_df = sales_processor.validate_sales(df, config)
    results, valid_sales = sales_processor.process_sales(validated_df, config)
    assert valid_sales == 0, "Should have 0 valid sales"
    assert results["total_sales"] == 0.0, "Total sales should be 0"

def test_invalid_csv(config: Dict[str, Any]) -> None:
    """Test pipeline with invalid CSV (wrong headers)."""
    df, valid_sales, total_records = sales_processor.load_and_validate_sales("data/invalid.csv", config)
    results, valid_sales = sales_processor.process_sales(df, config)
    assert valid_sales == 0, "Should have 0 valid sales due to missing 'product' column"
    assert results["total_sales"] == 0.0, "Total sales should be 0"

def test_negative_csv(config: Dict[str, Any]) -> None:
    """Test pipeline with negative CSV (negative prices)."""
    sales_processor.load_to_db("data/negative.csv", "data/sales.db", "sales", config)
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    validated_df = sales_processor.validate_sales(df, config)
    results, valid_sales = sales_processor.process_sales(validated_df, config)
    assert valid_sales == 1, "Should have 1 valid sale"
    assert results["total_sales"] == pytest.approx(249.90, 0.01), "Total sales incorrect"

sale = {"product": "Halal Laptop", "price": "999.99", "quantity": "150"}
config = {"min_price": 10.0, "max_quantity": 100, "required_fields": ["product", "price", "quantity"], "product_prefix": "Halal", "max_decimals": 2}

mock_df = pd.DataFrame({
    "product": ["Halal Laptop"],
    "price": [999.99],
    "quantity": [2]
})

from typing import Any
import pytest
from unittest.mock import patch, Mock
import pandas as pd
import sales_processor

@patch("sqlalchemy.create_engine")
@patch("pandas.read_sql")
def test_load_sales_mock_db_ex4(mock_read_sql: Mock, mock_create_engine: Mock) -> None:
    """Test loading sales with mocked database."""
    mock_df = pd.DataFrame({
        "name": ["Halal Laptop"],  # Bug: Wrong column name
        "price": [999.99],
        "quantity": [2]
    })
    mock_engine = Mock()
    mock_create_engine.return_value = mock_engine
    mock_read_sql.return_value = mock_df
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    assert df["product"].tolist() == ["Halal Laptop"], "Incorrect products"

from typing import Dict, Any
import requests

def fetch_sales_data(api_url: str) -> Dict[str, Any]:
    """Fetch sales data from an API endpoint."""
    response = requests.get(api_url)
    return response.json()

from typing import Dict, Any  # For type annotations
import pytest  # For testing
import utils  # Import utils module

def test_validate_sale_excessive_quantity() -> None:
    """Test sale with excessive quantity."""
    config: Dict[str, Any] = {
        "min_price": 10.0,
        "max_quantity": 100,
        "required_fields": ["product", "price", "quantity"],
        "product_prefix": "Halal",
        "max_decimals": 2
    }
    sale: Dict[str, str] = {
        "product": "Halal Laptop",
        "price": "999.99",
        "quantity": "150"
    }
    result: bool = utils.validate_sale(sale, config)
    assert result is False, "Sale with excessive quantity should fail"

from typing import Dict, Any, Tuple  # For type annotations
import pandas as pd  # For DataFrame
import pytest  # For testing
import sales_processor  # Import pipeline module
import yaml  # For YAML parsing

@pytest.fixture
def config() -> Dict[str, Any]:
    """Fixture for config."""
    with open("data/config.yaml", "r") as file:
        return yaml.safe_load(file)

def test_pipeline_sample_csv(config: Dict[str, Any]) -> None:
    """Test pipeline with sample.csv."""
    sales_processor.load_to_db("data/sample.csv", "data/sales.db", "sales", config)
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    validated_df = sales_processor.validate_sales(df, config)
    results, valid_sales = sales_processor.process_sales(validated_df, config)
    assert valid_sales == 2, "Should have 2 valid sales"
    assert results["total_sales"] == pytest.approx(2249.88, 0.01), "Total sales incorrect"

from typing import Any  # For type annotations
import pytest  # For testing
from unittest.mock import patch, Mock  # For mocking
import pandas as pd  # For DataFrame
import sales_processor  # Import pipeline module

@patch("sqlalchemy.create_engine")
@patch("pandas.read_sql")
def test_load_sales_mock_db_ex3(mock_read_sql: Mock, mock_create_engine: Mock) -> None:
    """Test loading sales with mocked database."""
    mock_df = pd.DataFrame({
        "product": ["Halal Laptop"],
        "price": [999.99],
        "quantity": [2]
    })
    mock_engine = Mock()
    mock_create_engine.return_value = mock_engine
    mock_read_sql.return_value = mock_df
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    assert len(df) == 1, "Should load 1 row"
    mock_create_engine.assert_called_once_with("sqlite:///data/sales.db")
    mock_read_sql.assert_called_once_with("SELECT * FROM sales", mock_engine)

from typing import Any  # For type annotations
import pytest  # For testing
from unittest.mock import patch, Mock  # For mocking
import pandas as pd  # For DataFrame
import sales_processor  # Import pipeline module

@patch("sqlalchemy.create_engine")
@patch("pandas.read_sql")
def test_load_sales_mock_db_ex4(mock_read_sql: Mock, mock_create_engine: Mock) -> None:
    """Test loading sales with mocked database."""
    mock_df = pd.DataFrame({
        "product": ["Halal Laptop"],  # Fix: Correct column name
        "price": [999.99],
        "quantity": [2]
    })
    mock_engine = Mock()
    mock_create_engine.return_value = mock_engine
    mock_read_sql.return_value = mock_df
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    assert df["product"].tolist() == ["Halal Laptop"], "Incorrect products"

from typing import Dict, Any  # For type annotations
import pytest  # For testing
import sales_processor  # Import pipeline module
import yaml  # For YAML parsing

@pytest.fixture
def config() -> Dict[str, Any]:
    """Fixture for config."""
    with open("data/config.yaml", "r") as file:
        return yaml.safe_load(file)

def test_malformed_csv(config: Dict[str, Any]) -> None:
    """Test pipeline with malformed.csv."""
    sales_processor.load_to_db("data/malformed.csv", "data/sales.db", "sales", config)
    df = sales_processor.load_sales_from_db("sqlite:///data/sales.db", "sales")
    validated_df = sales_processor.validate_sales(df, config)
    results, valid_sales = sales_processor.process_sales(validated_df, config)
    assert valid_sales == 1, "Should have 1 valid sale"
    assert results["total_sales"] == pytest.approx(249.90, 0.01), "Total sales incorrect"

from typing import Dict, Any  # For type annotations
import pytest  # For testing
from unittest.mock import patch, Mock  # For mocking
import sales_api  # Import API module

@patch("requests.get")
def test_fetch_sales_data(mock_get: Mock) -> None:
    """Test fetching sales data with mocked API."""
    mock_response = Mock()
    mock_response.json.return_value = {
        "sales": [{"product": "Halal Laptop", "price": 999.99, "quantity": 2}]
    }
    mock_get.return_value = mock_response
    result: Dict[str, Any] = sales_api.fetch_sales_data("https://api.example.com/sales")
    assert result == {"sales": [{"product": "Halal Laptop", "price": 999.99, "quantity": 2}]}, "Incorrect sales data"
    mock_get.assert_called_once_with("https://api.example.com/sales")