amazon-sp-cli 0.1.0__tar.gz

amazon_sp_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stellar Aether
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

amazon_sp_cli-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include tests *.py

amazon_sp_cli-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: amazon-sp-cli
+Version: 0.1.0
+Summary: CLI tool for Amazon Selling Partner API (SP-API) operations
+Home-page: https://github.com/stellaraether/amazon-sp-cli
+Author: Lunan Li
+Author-email: lunan@stellaraether.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.27.0
+Requires-Dist: boto3>=1.20.0
+Requires-Dist: pyyaml>=6.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

amazon_sp_cli-0.1.0/README.md

@@ -0,0 +1,100 @@
+# Amazon SP-API CLI
+
+Command line interface for Amazon Selling Partner API (SP-API) operations.
+
+## Features
+
+- **Pricing Management** — Get/set prices, create discounts
+- **Listing Operations** — View and update listings
+- **Catalog Lookup** — Check competitor ASINs
+- **Inventory Checks** — View FBA inventory levels
+- **Feed Submissions** — Bulk updates via feeds API
+
+## Installation
+
+```bash
+pip install amazon-sp-cli
+```
+
+## Setup
+
+Create credentials file at `~/.config/amazon-sp-cli/credentials.yml`:
+
+```yaml
+version: '1.0'
+
+default:
+  refresh_token: "your-refresh-token"
+  client_id: "your-client-id"
+  client_secret: "your-client-secret"
+  aws_access_key_id: "your-aws-access-key"
+  aws_secret_access_key: "your-aws-secret-key"
+  seller_id: "your-seller-id"
+  marketplace_id: "ATVPDKIKX0DER"  # US marketplace
+```
+
+## Usage
+
+### Pricing
+
+```bash
+# Get current price
+amz-sp pricing get PAW2603190101-BLU
+
+# Set new price
+amz-sp pricing set PAW2603190101-BLU 11.99
+
+# Create discount feed
+amz-sp pricing discount PAW2603190101-BLU 23
+```
+
+### Listings
+
+```bash
+# Get listing details
+amz-sp listings get PAW2603190101-BLU
+
+# Update listing
+amz-sp listings update PAW2603190101-BLU --data '{...}'
+```
+
+### Catalog
+
+```bash
+# Check competitor
+amz-sp catalog get B0GW72JGWK
+```
+
+### Inventory
+
+```bash
+# Get FBA inventory
+amz-sp inventory list
+
+# Get specific SKU
+amz-sp inventory get PAW2603190101-BLU
+```
+
+## Development
+
+```bash
+# Clone repo
+git clone https://github.com/stellaraether/amazon-sp-cli.git
+cd amazon-sp-cli
+
+# Install in editable mode
+pip install -e .
+
+# Run locally
+python3 -m amazon_sp_cli.main pricing get PAW2603190101-BLU
+```
+
+## Requirements
+
+- Python 3.8+
+- Amazon SP-API credentials
+- AWS IAM user with SP-API access
+
+## License
+
+MIT

amazon_sp_cli-0.1.0/amazon_sp_cli/__init__.py

@@ -0,0 +1,2 @@
+# Amazon SP-API CLI
+__version__ = "0.1.0"

amazon_sp_cli-0.1.0/amazon_sp_cli/auth.py

@@ -0,0 +1,103 @@
+"""Amazon SP-API authentication handler."""
+
+import json
+import os
+import time
+from pathlib import Path
+
+import requests
+import yaml
+
+
+class SPAPIAuth:
+    """Handles SP-API token refresh and caching."""
+
+    TOKEN_ENDPOINT = "https://api.amazon.com/auth/o2/token"
+    CACHE_FILE = Path.home() / ".config" / "amazon-sp-pricing" / "token-cache.json"
+    BUFFER_SECONDS = 60
+
+    def __init__(self, credentials_path: str = None):
+        self.credentials = self._load_credentials(credentials_path)
+        self._ensure_cache_dir()
+
+    def _load_credentials(self, path: str = None) -> dict:
+        """Load credentials from YAML file."""
+        if path is None:
+            path = Path.home() / ".config" / "amazon-sp-pricing" / "credentials.yml"
+
+        with open(path, "r") as f:
+            config = yaml.safe_load(f)
+
+        return config.get("default", config)
+
+    def _ensure_cache_dir(self):
+        """Ensure cache directory exists."""
+        self.CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    def _load_cache(self) -> dict:
+        """Load token cache from disk."""
+        if self.CACHE_FILE.exists():
+            with open(self.CACHE_FILE, "r") as f:
+                return json.load(f)
+        return {
+            "access_token": None,
+            "expires_at": 0,
+            "refreshed_at": None,
+        }
+
+    def _save_cache(self, cache: dict):
+        """Save token cache to disk."""
+        with open(self.CACHE_FILE, "w") as f:
+            json.dump(cache, f)
+        os.chmod(self.CACHE_FILE, 0o600)
+
+    def _is_token_valid(self, cache: dict) -> bool:
+        """Check if cached token is still valid."""
+        if cache.get("access_token") is None:
+            return False
+        now = time.time()
+        return now < cache.get("expires_at", 0) - self.BUFFER_SECONDS
+
+    def _exchange_token(self) -> dict:
+        """Exchange refresh token for access token."""
+        response = requests.post(
+            self.TOKEN_ENDPOINT,
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            data={
+                "grant_type": "refresh_token",
+                "refresh_token": self.credentials["refresh_token"],
+                "client_id": self.credentials["client_id"],
+                "client_secret": self.credentials["client_secret"],
+            },
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        now = time.time()
+        return {
+            "access_token": data["access_token"],
+            "expires_at": now + data["expires_in"],
+            "refreshed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        }
+
+    def get_access_token(self) -> str:
+        """Get a valid access token, refreshing if necessary."""
+        cache = self._load_cache()
+
+        # Fast path: valid cached token
+        if self._is_token_valid(cache):
+            return cache["access_token"]
+
+        # Slow path: refresh token
+        new_cache = self._exchange_token()
+        self._save_cache(new_cache)
+        return new_cache["access_token"]
+
+    def invalidate(self):
+        """Invalidate cached token."""
+        self._save_cache({
+            "access_token": None,
+            "expires_at": 0,
+            "refreshed_at": None,
+        })
+        print("Token cache invalidated.")

amazon_sp_cli-0.1.0/amazon_sp_cli/client.py

@@ -0,0 +1,104 @@
+"""Amazon SP-API client with AWS SigV4 signing."""
+
+import json
+from urllib.parse import urlencode
+
+import requests
+from botocore.auth import SigV4Auth
+from botocore.awsrequest import AWSRequest
+from botocore.credentials import Credentials
+from botocore.session import Session
+
+
+class SPAPIClient:
+    """Client for making signed requests to Amazon SP-API."""
+
+    HOST = "sellingpartnerapi-na.amazon.com"
+    REGION = "us-east-1"
+    SERVICE = "execute-api"
+
+    def __init__(self, auth, aws_access_key: str = None, aws_secret_key: str = None):
+        self.auth = auth
+        self.credentials = auth.credentials
+        self.aws_access_key = aws_access_key or self.credentials.get("aws_access_key_id")
+        self.aws_secret_key = aws_secret_key or self.credentials.get("aws_secret_access_key")
+        self.marketplace_id = self.credentials.get("marketplace_id", "ATVPDKIKX0DER")
+        self.seller_id = self.credentials.get("seller_id")
+
+    def _sign_request(self, method: str, path: str, data: dict = None) -> dict:
+        """Create signed request headers."""
+        access_token = self.auth.get_access_token()
+
+        headers = {
+            "x-amz-access-token": access_token,
+            "accept": "application/json",
+        }
+
+        if data is not None:
+            headers["content-type"] = "application/json"
+
+        # Create the request
+        url = f"https://{self.HOST}{path}"
+        body = json.dumps(data) if data else ""
+
+        # Create AWS request for signing
+        request = AWSRequest(method=method, url=url, headers=headers, data=body)
+
+        # Sign with SigV4
+        credentials = Credentials(self.aws_access_key, self.aws_secret_key)
+        signer = SigV4Auth(credentials, self.SERVICE, self.REGION)
+        signer.add_auth(request)
+
+        return dict(request.headers), request.url, body
+
+    def request(self, method: str, path: str, data: dict = None) -> dict:
+        """Make a signed request to SP-API."""
+        headers, url, body = self._sign_request(method, path, data)
+
+        response = requests.request(method, url, headers=headers, data=body)
+        response.raise_for_status()
+
+        return response.json() if response.text else {}
+
+    def get_listing(self, sku: str) -> dict:
+        """Get listing information for a SKU."""
+        path = f"/listings/2021-08-01/items/{self.seller_id}/{sku}"
+        params = {
+            "marketplaceIds": self.marketplace_id,
+            "includedData": "summaries,attributes",
+        }
+        path += "?" + urlencode(params)
+        return self.request("GET", path)
+
+    def update_price(self, sku: str, price: float, mode: str = "VALIDATION_PREVIEW") -> dict:
+        """Update listing price."""
+        path = f"/listings/2021-08-01/items/{self.seller_id}/{sku}"
+        params = {
+            "marketplaceIds": self.marketplace_id,
+        }
+        if mode:
+            params["mode"] = mode
+        path += "?" + urlencode(params)
+
+        data = {
+            "productType": "PET_TOY",
+            "requirements": "LISTING_OFFER_ONLY",
+            "attributes": {
+                "condition_type": [{"value": "new_new"}],
+                "item_name": [{"value": "Placeholder"}],
+                "list_price": [{"currency": "USD", "value": price}],
+                "purchasable_price": [{"currency": "USD", "value": price}],
+            },
+        }
+
+        return self.request("PUT", path, data)
+
+    def get_catalog_item(self, asin: str) -> dict:
+        """Get catalog item details."""
+        path = f"/catalog/2022-04-01/items/{asin}"
+        params = {
+            "marketplaceIds": self.marketplace_id,
+            "includedData": "attributes,salesRanks",
+        }
+        path += "?" + urlencode(params)
+        return self.request("GET", path)

amazon_sp_cli-0.1.0/amazon_sp_cli/main.py

@@ -0,0 +1,175 @@
+"""Main CLI entry point for Amazon SP-API CLI."""
+
+import json
+from datetime import datetime, timezone
+
+import click
+
+from .auth import SPAPIAuth
+from .client import SPAPIClient
+
+
+@click.group()
+@click.option("--credentials", "-c", help="Path to credentials YAML file")
+@click.pass_context
+def cli(ctx, credentials):
+    """Amazon SP-API CLI - Manage listings, pricing, inventory, and more."""
+    ctx.ensure_object(dict)
+    ctx.obj["auth"] = SPAPIAuth(credentials)
+    ctx.obj["client"] = SPAPIClient(ctx.obj["auth"])
+
+
+@cli.command()
+@click.argument("sku")
+@click.pass_context
+def get_price(ctx, sku):
+    """Get current price for a SKU."""
+    client = ctx.obj["client"]
+    try:
+        response = client.get_listing(sku)
+        attributes = response.get("attributes", {})
+        list_price = attributes.get("list_price", [{}])[0]
+
+        result = {
+            "sku": sku,
+            "asin": response.get("summaries", [{}])[0].get("asin"),
+            "status": response.get("summaries", [{}])[0].get("status", []),
+            "price": list_price.get("value"),
+            "currency": list_price.get("currency"),
+        }
+        click.echo(json.dumps(result, indent=2))
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+@cli.command()
+@click.argument("sku")
+@click.argument("price", type=float)
+@click.option("--dry-run", is_flag=True, help="Validate without applying")
+@click.pass_context
+def set_price(ctx, sku, price, dry_run):
+    """Set price for a SKU."""
+    client = ctx.obj["client"]
+    try:
+        mode = "VALIDATION_PREVIEW" if dry_run else None
+        response = client.update_price(sku, price, mode)
+
+        if dry_run:
+            if response.get("issues"):
+                click.echo("Validation issues found:")
+                click.echo(json.dumps(response["issues"], indent=2))
+            else:
+                click.echo("✓ Validation passed")
+        else:
+            click.echo(json.dumps(response, indent=2))
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+@cli.command()
+@click.argument("sku")
+@click.argument("percent", type=float)
+@click.option("--all-variations", is_flag=True, help="Apply to all variations")
+@click.pass_context
+def create_discount(ctx, sku, percent, all_variations):
+    """Create discount for a SKU."""
+    client = ctx.obj["client"]
+
+    try:
+        if all_variations:
+            # Get parent SKU and find all variations
+            parent_sku = sku.split("-")[0] if "-" in sku else sku
+            click.echo(f"Creating {percent}% discount for all variations of {parent_sku}")
+            # TODO: Implement variation discovery
+            return
+
+        # Get current price
+        response = client.get_listing(sku)
+        attributes = response.get("attributes", {})
+        list_price = attributes.get("list_price", [{}])[0]
+        current_price = list_price.get("value", 0)
+
+        if not current_price:
+            click.echo("Error: Could not get current price", err=True)
+            raise click.Abort()
+
+        sale_price = round(current_price * (100 - percent) / 100, 2)
+        effective_date = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        click.echo(f"Current price: ${current_price}")
+        click.echo(f"Sale price: ${sale_price} ({percent}% off)")
+        click.echo("")
+        click.echo("Note: SP-API doesn't support direct discount creation.")
+        click.echo("Options:")
+        click.echo("1. Seller Central → Advertising → Prime Exclusive Discounts")
+        click.echo("2. Seller Central → Advertising → Coupons")
+        click.echo("3. Submit feed via SP-API Feeds API")
+        click.echo("")
+        click.echo("Feed data for option 3:")
+
+        feed = {
+            "header": {
+                "sellerId": client.seller_id,
+                "version": "2.0",
+                "issueLocale": "en_US",
+            },
+            "messages": [
+                {
+                    "messageId": 1,
+                    "sku": sku,
+                    "operationType": "PARTIAL_UPDATE",
+                    "productType": "PET_TOY",
+                    "attributes": {
+                        "list_price": [{"currency": "USD", "value": current_price}],
+                        "sale_price": [
+                            {
+                                "currency": "USD",
+                                "value": sale_price,
+                                "effective_date": effective_date,
+                            }
+                        ],
+                    },
+                }
+            ],
+        }
+        click.echo(json.dumps(feed, indent=2))
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+@cli.command()
+@click.argument("asin")
+@click.pass_context
+def check_competitors(ctx, asin):
+    """Check competitor pricing for an ASIN."""
+    client = ctx.obj["client"]
+    try:
+        response = client.get_catalog_item(asin)
+        attributes = response.get("attributes", {})
+
+        result = {
+            "asin": response.get("asin"),
+            "title": attributes.get("item_name", [{}])[0].get("value"),
+            "brand": attributes.get("brand", [{}])[0].get("value"),
+            "list_price": attributes.get("list_price", [{}])[0].get("value"),
+            "sales_rank": response.get("salesRanks", [{}])[0].get("displayRank"),
+        }
+        click.echo(json.dumps(result, indent=2))
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        raise click.Abort()
+
+
+@cli.command()
+@click.pass_context
+def invalidate(ctx):
+    """Invalidate cached access token."""
+    ctx.obj["auth"].invalidate()
+
+
+if __name__ == "__main__":
+    cli()

amazon_sp_cli-0.1.0/amazon_sp_cli.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: amazon-sp-cli
+Version: 0.1.0
+Summary: CLI tool for Amazon Selling Partner API (SP-API) operations
+Home-page: https://github.com/stellaraether/amazon-sp-cli
+Author: Lunan Li
+Author-email: lunan@stellaraether.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.27.0
+Requires-Dist: boto3>=1.20.0
+Requires-Dist: pyyaml>=6.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

amazon_sp_cli-0.1.0/amazon_sp_cli.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+amazon_sp_cli/__init__.py
+amazon_sp_cli/auth.py
+amazon_sp_cli/client.py
+amazon_sp_cli/main.py
+amazon_sp_cli.egg-info/PKG-INFO
+amazon_sp_cli.egg-info/SOURCES.txt
+amazon_sp_cli.egg-info/dependency_links.txt
+amazon_sp_cli.egg-info/entry_points.txt
+amazon_sp_cli.egg-info/requires.txt
+amazon_sp_cli.egg-info/top_level.txt
+tests/__init__.py
+tests/test_auth.py
+tests/test_client.py

amazon_sp_cli-0.1.0/amazon_sp_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

amazon_sp_cli-0.1.0/amazon_sp_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+amz-sp = amazon_sp_cli.main:cli

amazon_sp_cli-0.1.0/amazon_sp_cli.egg-info/requires.txt

@@ -0,0 +1,4 @@
+click>=8.0
+requests>=2.27.0
+boto3>=1.20.0
+pyyaml>=6.0

amazon_sp_cli-0.1.0/amazon_sp_cli.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+amazon_sp_cli
+tests

amazon_sp_cli-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 120
+target-version = ['py38', 'py39', 'py310', 'py311']
+
+[tool.isort]
+profile = "black"
+line_length = 120
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "--strict-markers"

amazon_sp_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

amazon_sp_cli-0.1.0/setup.py

@@ -0,0 +1,33 @@
+from setuptools import find_packages, setup
+
+setup(
+    name="amazon-sp-cli",
+    version="0.1.0",
+    description="CLI tool for Amazon Selling Partner API (SP-API) operations",
+    author="Lunan Li",
+    author_email="lunan@stellaraether.com",
+    url="https://github.com/stellaraether/amazon-sp-cli",
+    packages=find_packages(),
+    install_requires=[
+        "click>=8.0",
+        "requests>=2.27.0",
+        "boto3>=1.20.0",
+        "pyyaml>=6.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "amz-sp=amazon_sp_cli.main:cli",
+        ],
+    },
+    python_requires=">=3.8",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+)

amazon_sp_cli-0.1.0/tests/__init__.py

@@ -0,0 +1 @@
+# Tests package

amazon_sp_cli-0.1.0/tests/test_auth.py

@@ -0,0 +1,116 @@
+"""Tests for SP-API authentication."""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+
+from amazon_sp_cli.auth import SPAPIAuth
+
+
+class TestSPAPIAuth:
+    """Test SPAPIAuth class."""
+
+    @pytest.fixture
+    def temp_credentials(self):
+        """Create temporary credentials file."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False) as f:
+            f.write("""
+default:
+  refresh_token: "test-refresh-token"
+  client_id: "test-client-id"
+  client_secret: "test-client-secret"
+""")
+            path = f.name
+        yield path
+        os.unlink(path)
+
+    @pytest.fixture
+    def temp_cache_dir(self):
+        """Create temporary cache directory."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            cache_file = Path(tmpdir) / "token-cache.json"
+            with patch.object(SPAPIAuth, "CACHE_FILE", cache_file):
+                yield cache_file
+
+    def test_load_credentials(self, temp_credentials):
+        """Test credentials loading."""
+        auth = SPAPIAuth(temp_credentials)
+        assert auth.credentials["refresh_token"] == "test-refresh-token"
+        assert auth.credentials["client_id"] == "test-client-id"
+        assert auth.credentials["client_secret"] == "test-client-secret"
+
+    def test_token_valid(self, temp_credentials, temp_cache_dir):
+        """Test token validation."""
+        auth = SPAPIAuth(temp_credentials)
+
+        # Valid token
+        valid_cache = {
+            "access_token": "valid-token",
+            "expires_at": 9999999999,
+        }
+        assert auth._is_token_valid(valid_cache) is True
+
+        # Expired token
+        expired_cache = {
+            "access_token": "expired-token",
+            "expires_at": 0,
+        }
+        assert auth._is_token_valid(expired_cache) is False
+
+        # No token
+        empty_cache = {"access_token": None}
+        assert auth._is_token_valid(empty_cache) is False
+
+    @patch("amazon_sp_cli.auth.requests.post")
+    def test_exchange_token(self, mock_post, temp_credentials, temp_cache_dir):
+        """Test token exchange."""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "access_token": "new-access-token",
+            "expires_in": 3600,
+        }
+        mock_response.raise_for_status = Mock()
+        mock_post.return_value = mock_response
+
+        auth = SPAPIAuth(temp_credentials)
+        cache = auth._exchange_token()
+
+        assert cache["access_token"] == "new-access-token"
+        assert cache["expires_at"] > 0
+
+    @patch("amazon_sp_cli.auth.requests.post")
+    def test_get_access_token_cached(self, mock_post, temp_credentials, temp_cache_dir):
+        """Test getting cached access token."""
+        auth = SPAPIAuth(temp_credentials)
+
+        # Pre-populate cache with valid token
+        cache = {
+            "access_token": "cached-token",
+            "expires_at": 9999999999,
+        }
+        auth._save_cache(cache)
+
+        token = auth.get_access_token()
+        assert token == "cached-token"
+        mock_post.assert_not_called()
+
+    def test_invalidate(self, temp_credentials, temp_cache_dir):
+        """Test token invalidation."""
+        auth = SPAPIAuth(temp_credentials)
+
+        # Pre-populate cache
+        cache = {
+            "access_token": "token",
+            "expires_at": 9999999999,
+        }
+        auth._save_cache(cache)
+
+        auth.invalidate()
+
+        new_cache = auth._load_cache()
+        assert new_cache["access_token"] is None
+        assert new_cache["expires_at"] == 0

amazon_sp_cli-0.1.0/tests/test_client.py

@@ -0,0 +1,59 @@
+"""Tests for SP-API client."""
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from amazon_sp_cli.auth import SPAPIAuth
+from amazon_sp_cli.client import SPAPIClient
+
+
+class TestSPAPIClient:
+    """Test SPAPIClient class."""
+
+    @pytest.fixture
+    def mock_auth(self):
+        """Create mock auth object."""
+        auth = Mock(spec=SPAPIAuth)
+        auth.credentials = {
+            "aws_access_key_id": "test-aws-key",
+            "aws_secret_access_key": "test-aws-secret",
+            "seller_id": "TESTSELLER",
+            "marketplace_id": "ATVPDKIKX0DER",
+        }
+        auth.get_access_token.return_value = "test-access-token"
+        return auth
+
+    @pytest.fixture
+    def client(self, mock_auth):
+        """Create SPAPIClient instance."""
+        return SPAPIClient(mock_auth)
+
+    def test_init(self, client, mock_auth):
+        """Test client initialization."""
+        assert client.auth == mock_auth
+        assert client.seller_id == "TESTSELLER"
+        assert client.marketplace_id == "ATVPDKIKX0DER"
+
+    def test_get_listing_path(self, client):
+        """Test listing path construction."""
+        path = f"/listings/2021-08-01/items/{client.seller_id}/TEST-SKU"
+        assert "TESTSELLER" in path
+        assert "TEST-SKU" in path
+
+    @patch("amazon_sp_cli.client.requests.request")
+    @patch("amazon_sp_cli.client.SigV4Auth")
+    def test_request(self, mock_signer_class, mock_request, client):
+        """Test API request."""
+        mock_response = Mock()
+        mock_response.json.return_value = {"test": "data"}
+        mock_response.text = '{"test": "data"}'
+        mock_request.return_value = mock_response
+
+        mock_signer = Mock()
+        mock_signer_class.return_value = mock_signer
+
+        result = client.request("GET", "/test/path")
+
+        assert result == {"test": "data"}
+        mock_request.assert_called_once()