import random
import requests
from datetime import datetime, timedelta

class APIRoulette:
    """
    Simulates unpredictable API behavior to test your resilience.
    Because APIs don't break politely - they go out with a bang.
    """
    
    def __init__(self, base_url):
        self.base_url = base_url
        self.deprecation_scenarios = [
            'version_mismatch',
            'rate_limit_surprise',
            'schema_drift',
            'silent_failure',
            'auth_roulette'
        ]
    
    def spin_the_chamber(self, endpoint):
        """
        Makes an API call with random failure injection.
        Returns: (status_code, response_data, scenario_triggered)
        """
        scenario = random.choice(self.deprecation_scenarios)
        
        # Simulate different failure modes
        if scenario == 'version_mismatch':
            # API returns 200 but with deprecated structure
            return 200, {"message": "Success", "legacy_field": "deprecated_value"}, scenario
            
        elif scenario == 'rate_limit_surprise':
            # Unexpected 429 with no headers
            return 429, {"error": "Too many requests (but we won't tell you the limit)"}, scenario
            
        elif scenario == 'schema_drift':
            # Valid JSON but missing required fields
            return 200, {"partial_data": "Here's some data", "missing": "required_field"}, scenario
            
        elif scenario == 'silent_failure':
            # The API just stops responding
            raise requests.exceptions.ConnectionError("API entered witness protection")
            
        elif scenario == 'auth_roulette':
            # Random auth failures
            return random.choice([401, 403]), {"error": "Not today, friend"}, scenario
        
        # Default: actual API call
        try:
            response = requests.get(f"{self.base_url}/{endpoint}", timeout=5)
            return response.status_code, response.json(), 'stable'
        except Exception as e:
            return 500, {"error": str(e)}, 'unexpected_failure'
    
    def test_endpoint_resilience(self, endpoint, spins=10):
        """
        Run multiple tests to see how your code handles chaos.
        """
        results = []
        for i in range(spins):
            try:
                status, data, scenario = self.spin_the_chamber(endpoint)
                results.append({
                    'spin': i+1,
                    'status': status,
                    'scenario': scenario,
                    'survived': status == 200 and scenario == 'stable'
                })
            except Exception as e:
                results.append({
                    'spin': i+1,
                    'status': 'ERROR',
                    'scenario': 'crash',
                    'survived': False,
                    'error': str(e)
                })
        
        survival_rate = sum(1 for r in results if r['survived']) / len(results)
        return {
            'endpoint': endpoint,
            'total_spins': spins,
            'survival_rate': f"{survival_rate:.0%}",
            'results': results
        }

# Usage example:
# roulette = APIRoulette("https://api.example.com")
# report = roulette.test_endpoint_resilience("users/me", spins=5)
# print(f"Your API survived {report['survival_rate']} of random attacks")

The Problem: When APIs Go to the Great Cloud in the Sky

Let's talk about the beautiful, predictable lifecycle of modern APIs. First, there's the grand announcement: "We're excited to introduce our new v2 API with enhanced capabilities!" Translation: "We're about to break everything you've built, but we'll give you six months to figure it out." Then comes the migration guide—a 47-page PDF that somehow manages to be both overly detailed and completely useless, like IKEA instructions written by a poet on mushrooms.

The real magic happens when the documentation says one thing, the API does another, and the support forum has a single response from 2019 saying "we're looking into this." You'll find yourself in API limbo—that special place where endpoints return 200 OK but with completely different response structures, or worse, they just... stop. No warning. No error. Just digital silence, like your API call entered the witness protection program.

My personal favorite is the "surprise maintenance" culture. You know the drill: it's 2 AM, your phone buzzes with 500 alerts, and you discover that an API you've been using for years has been "temporarily disabled for improvements." Temporary, of course, meaning "until we remember to turn it back on, which might be never." It's like your infrastructure is being managed by a cat who occasionally walks across the keyboard.

The Solution: Introducing API Deprecation Roulette

I built API Deprecation Roulette because I got tired of playing "guess which endpoint will betray me today." This tool takes the anxiety out of API maintenance by adding... well, more anxiety, but at least it's organized anxiety. It's like having a canary in your coal mine, except the canary is sarcastic and occasionally generates bingo cards.

Here's how it works: you feed it your API documentation (OpenAPI/Swagger files work great), and it randomly selects endpoints to test. It then pokes them with virtual sticks to see if they're still alive, returning the expected responses, or have joined the great API graveyard in the sky. The beauty is in the randomness—just like real API deprecations, you never know what's going to break next!

Despite the humorous approach, this tool actually solves real problems. It helps you proactively identify endpoints that don't match documentation, catch silent deprecations before they become production fires, and maintain a realistic view of your API dependencies. Think of it as preventive medicine for your codebase, except the medicine is dark humor and the side effects include occasional existential dread about the state of modern software development.

How to Use It: Your Ticket to Organized Chaos

Getting started is easier than explaining to your manager why the API you said was "stable" just returned a 418 "I'm a teapot" status code. First, install the package:

npm install api-deprecation-roulette
# or
pip install api-deprecation-roulette

Then, create a simple configuration file pointing to your API documentation:

{
  "api_spec": "./openapi.json",
  "test_frequency": "daily",
  "alert_threshold": 3,
  "enable_sarcasm": true
}

Run the tool, and watch the magic (or tragedy) unfold:

from api_deprecation_roulette import Roulette

roulette = Roulette(config_path="./config.json")
results = roulette.spin()

for endpoint, status in results.items():
    if status == "DEPRECATED_UNANNOUNCED":
        print(f"🎉 Surprise! {endpoint} is dead!")
    elif status == "DOCUMENTATION_LIES":
        print(f"🤥 {endpoint} says one thing, does another")
    else:
        print(f"✅ {endpoint} actually works (for now...)")

Check out the full source code on GitHub for more examples and configuration options. The beauty of open source is that you can see exactly how the sausage is made—and in this case, the sausage is a tool that highlights how broken our API ecosystems can be.

Key Features: Because Regular Testing is Too Predictable

• Random Endpoint Selection: Why test everything systematically when you can embrace chaos? The tool randomly selects endpoints from your API documentation and checks if they're still alive, just like your users will discover them—completely by accident at 3 AM.
• Deprecation Bingo Cards: Generates beautiful bingo cards filled with buzzwords you'll actually encounter. Get a row of "sunsetting," "legacy," "enhanced experience," "temporary disruption," and "forward-looking improvements" and you win... absolutely nothing, but at least you saw it coming.
• Mock Migration Timelines: Produces realistic-looking migration timelines with increasingly absurd deadlines. "Q4 2023... maybe" and "We're targeting sometime before the heat death of the universe" help prepare you for the vague promises of actual API providers.
• Passive-Aggressive Status Reports: Instead of boring "Endpoint down" messages, get notifications like "This endpoint has decided to pursue other opportunities" or "The API you're looking for is currently unavailable due to 'reasons.'"
• Documentation Reality Check: Compares what your documentation promises with what your API actually delivers, highlighting discrepancies with the subtlety of a fireworks display in a library.

Conclusion: Embrace the Chaos, But Bring a Map

API Deprecation Roulette won't fix the broken culture of silent API changes and vague deprecation notices—that would require actual communication and consideration for developers, and we can't have that. What it will do is give you early warning when the API rug is about to be pulled out from under you, provide some much-needed humor in the face of infrastructure absurdity, and maybe, just maybe, help you sleep better at night knowing you're not completely at the mercy of someone else's "product vision."

Try it out today: https://github.com/BoopyCode/api-deprecation-roulette

Remember: in the game of API roulette, the house always wins. But at least with this tool, you'll know when they're about to spin the chamber.