ध्यान दीजिए: यह लेख खासकर एआई बनाया गया है ।

यह बहुत दिलचस्प है तो मैं इसे यहाँ डाल दिया है लेकिन अगर यह आप के लिए एक समस्या है आप इसे नज़रअंदाज़ करें.

परिचय

क्या कभी तुमने एक ऐसी API के खिलाफ परीक्षण करने की जरूरत है जो अभी तक तैयार नहीं थी?

कोई कॉन्फ़िगरेशन फ़ाइल नहीं.कोई हस्तचालित अंत- बिन्दु बनाने के लिए नहीं.बस इसे एक ओपनडी स्पेस में बिंदु और निवेदन शुरू करने के लिए शुरू करें.

लागू नहीं

आप पा सकते हैं

graph TD
    A[Your App] --> B{External API}
    B -->|Not Ready| C[Development Blocked]
    B -->|Rate Limited| D[Can't Test Freely]
    B -->|Requires Auth| E[Complex Setup]
    B -->|Expensive| F[Cost Concerns]
    B -->|Unreliable| G[Flaky Tests]

GiHh यहाँ

• परियोजना के लिए, सभी सार्वजनिक डोमेन...
• ओपन- पीजीपी प्रबंधक खोलें
• समस्या: एपीआई इंफेक्शन विकास

आधुनिक अनुप्रयोग दर्जनों बाहरी एपीआईओं पर निर्भर हैं ।

विकास के दौरान, आप कई चुनौतियों का सामना करते हैं:

1. पारंपरिक समाधान में सम्मिलित है:
2. ठट्ठा करनेवालों के जवाब को हस्तचालित लिखिए (शोधनी, पुरानी हो जाता है)
3. रिकार्डिंग/ रोलिंग HTTP ट्रैफिक (ब्रिटल, बनाए रखने के लिए कठिन)
4. हार्डकोड्स का उपयोग करना (सच्चेवादी, किनारा मामलों को कवर नहीं करता)

sequenceDiagram
    participant Dev as Developer
    participant System as Mock System
    participant Spec as OpenAPI Spec
    participant LLM as Local LLM

    Dev->>System: Load spec from URL/file
    System->>Spec: Parse OpenAPI document
    Spec-->>System: Endpoints, schemas, descriptions
    System->>System: Register dynamic routes

    Dev->>System: GET /petstore/pet/123
    System->>LLM: Generate data for "Pet" schema
    LLM-->>System: Realistic pet data
    System-->>Dev: {"id": 123, "name": "Max", ...}

समाधान: गतिशील ओपन- प्लेयर

तंत्र को किसी भी ओपनपीआई स्पेस में पाइंट करें, तथा यह स्वचालित रूप से:

स्पेसर को पारा करता है

graph TB
    A[HTTP Request] --> B{Route Matches?}
    B -->|No| C[404 Not Found]
    B -->|Yes| D[DynamicOpenApiManager]
    D --> E[Find Matching Endpoint]
    E --> F[OpenApiRequestHandler]
    F --> G[Extract Schema from Spec]
    G --> H[Build LLM Prompt]
    H --> I[PromptBuilder]
    I --> J[Include Context?]
    J -->|Yes| K[OpenApiContextManager]
    J -->|No| L[LLM Client]
    K --> L
    L --> M[Get Response]
    M --> N[JsonExtractor]
    N --> O[Return Mock Data]

सभी अंत- बिन्दुओं की खोज करता है

1. किसी TLM के उपयोग से वास्तविक उपहास डाटा उत्पन्न करता हैआपके स्थानीय मशीन पर नकली एपीआई सेवा करता है
2. यह कैसे कार्य करता हैओवरव्यू
3. **ओपनपीआई तंत्र बहुत से निर्देशांकों के अवयव है:**कुंजी अवयव:
4. गतिशील ओपन- पीजीपी प्रबंधक- लोड होने वाले स्पेस और रास्ते से मेल खाता प्रबंधन करता है
5. वीडियो- डीवीडी लोडर खोलें- लाने और ओपनपीआई दस्तावेज़ों की व्याख्या करें

ओपन- जीएल- डीहेप्टर खोलें

• मेल खाते अंत बिन्दुओं के लिए जवाब बनाता है

संकेत

POST /api/openapi/specs
Content-Type: application/json

{
  "name": "petstore",
  "source": "https://petstore3.swagger.io/api/v3/openapi.json",
  "basePath": "/petstore"
}

- LLLIM स्कीमा से प्रेरित करता है

POST /api/openapi/specs
Content-Type: application/json

{
  "name": "my-api",
  "source": "./specs/my-api.yaml",
  "basePath": "/api/v1"
}

प्रमाणपत्र प्रबंधक प्रारंभ करें

POST /api/openapi/specs
Content-Type: application/json

{
  "name": "inline-api",
  "source": "data:application/json;base64,eyJvcGVuYXBpIjoiMy...",
  "basePath": "/api"
}

- कॉल के पार सुसंगतता बनाए रखता है (वैकल्पिक)

विशेषताएँ लोड किया जा रहा है

public async Task<SpecLoadResult> LoadSpecAsync(
    string name,
    string source,
    string? basePath = null,
    string? contextName = null)
{
    // 1. Use scoped service factory for OpenApiSpecLoader
    using var scope = _scopeFactory.CreateScope();
    var specLoader = scope.ServiceProvider
        .GetRequiredService<OpenApiSpecLoader>();

    // 2. Load the OpenAPI document
    var document = await specLoader.LoadSpecAsync(source);

    // 3. Determine base path from spec or parameter
    var effectiveBasePath = basePath
        ?? document.Servers?.FirstOrDefault()?.Url
        ?? "/api";

    // 4. Store spec with configuration
    var config = new OpenApiSpecConfig
    {
        Name = name,
        Source = source,
        Document = document,
        BasePath = effectiveBasePath,
        ContextName = contextName,
        LoadedAt = DateTimeOffset.UtcNow
    };

    _specs.AddOrUpdate(name, config, (_, __) => config);

    // 5. Notify listeners via SignalR
    await NotifySpecLoaded(name, effectiveBasePath);

    return new SpecLoadResult
    {
        Name = name,
        BasePath = effectiveBasePath,
        EndpointCount = CountEndpoints(document),
        Success = true
    };
}

तीन स्रोतों से युक्ति लोड की जा सकती है:

1 ..

public OpenApiEndpointMatch? FindMatchingEndpoint(string path, string method)
{
    // Try each loaded spec
    foreach (var spec in _specs.Values)
    {
        // Remove base path prefix
        var relativePath = path;
        if (path.StartsWith(spec.BasePath))
        {
            relativePath = path.Substring(spec.BasePath.Length);
        }

        // Find matching path in OpenAPI document
        var (pathTemplate, operation) = FindOperation(
            spec.Document,
            relativePath,
            method);

        if (operation != null)
        {
            return new OpenApiEndpointMatch
            {
                Spec = spec,
                PathTemplate = pathTemplate,
                Operation = operation,
                Method = ParseMethod(method)
            };
        }
    }

    return null;
}

रिमोट यूआरएल

2

public async Task<string> HandleRequestAsync(
    HttpContext context,
    OpenApiDocument document,
    string path,
    OperationType method,
    OpenApiOperation operation,
    string? contextName = null,
    CancellationToken cancellationToken = default)
{
    // 1. Extract request body
    var requestBody = await ReadRequestBodyAsync(context.Request);

    // 2. Get success response schema
    var shape = ExtractResponseSchema(operation);

    // 3. Get context history if using contexts
    var contextHistory = !string.IsNullOrWhiteSpace(contextName)
        ? _contextManager.GetContextForPrompt(contextName)
        : null;

    // 4. Build prompt from OpenAPI metadata
    var description = operation.Summary ?? operation.Description;
    var prompt = _promptBuilder.BuildPrompt(
        method.ToString(),
        path,
        requestBody,
        new ShapeInfo { Shape = shape },
        streaming: false,
        description: description,
        contextHistory: contextHistory);

    // 5. Get response from LLM
    var rawResponse = await _llmClient.GetCompletionAsync(
        prompt,
        cancellationToken);

    // 6. Extract clean JSON
    var jsonResponse = JsonExtractor.ExtractJson(rawResponse);

    // 7. Store in context if configured
    if (!string.IsNullOrWhiteSpace(contextName))
    {
        _contextManager.AddToContext(
            contextName,
            method.ToString(),
            path,
            requestBody,
            jsonResponse);
    }

    return jsonResponse;
}

स्थानीय फ़ाइल

3

private string? ExtractResponseSchema(OpenApiOperation operation)
{
    // Look for successful response (2xx)
    var successResponse = operation.Responses
        .FirstOrDefault(r => r.Key.StartsWith("2"))
        .Value;

    if (successResponse == null)
        return null;

    // Get JSON content
    var jsonContent = successResponse.Content
        .FirstOrDefault(c => c.Key.Contains("json"))
        .Value;

    if (jsonContent?.Schema == null)
        return null;

    // Convert OpenAPI schema to JSON Schema
    return ConvertToJsonSchema(jsonContent.Schema);
}

private string ConvertToJsonSchema(OpenApiSchema schema)
{
    // Recursively build JSON Schema representation
    var builder = new StringBuilder();
    builder.Append("{");

    if (schema.Type != null)
    {
        builder.Append($"\"type\":\"{schema.Type}\"");
    }

    if (schema.Properties?.Count > 0)
    {
        builder.Append(",\"properties\":{");
        var props = schema.Properties
            .Select(p => $"\"{p.Key}\":{ConvertToJsonSchema(p.Value)}");
        builder.Append(string.Join(",", props));
        builder.Append("}");
    }

    if (schema.Items != null)
    {
        builder.Append(",\"items\":");
        builder.Append(ConvertToJsonSchema(schema.Items));
    }

    builder.Append("}");
    return builder.ToString();
}

डाटा यूआरएल (बेस64 एन्कोडेड)

री- लोड प्रक्रिया

यहाँ क्या होता है जब आप एक परत लोड करते हैं:

गतिशील गतिशील गतिशील मैचिंग

POST /api/openapi/specs
Content-Type: application/json

{
  "name": "petstore",
  "source": "https://petstore3.swagger.io/api/v3/openapi.json",
  "basePath": "/petstore"
}

जब निवेदन आता है, तंत्र इससे मेल खाता है सभी लोड होते हैं:

{
  "name": "petstore",
  "basePath": "/petstore",
  "endpointCount": 19,
  "endpoints": [
    {"path": "/petstore/pet", "method": "POST"},
    {"path": "/petstore/pet/{petId}", "method": "GET"},
    {"path": "/petstore/pet/findByStatus", "method": "GET"},
    ...
  ],
  "success": true
}

अनुरोधित हैंडलिंग

एक बार मेल खाते अंत बिन्दु मिल जाती है, हैंडलर प्रतिक्रिया बनाता है:

### Get a pet by ID
GET /petstore/pet/123

### Response (auto-generated):
{
  "id": 123,
  "name": "Max",
  "category": {
    "id": 1,
    "name": "Dogs"
  },
  "photoUrls": [
    "https://example.com/max1.jpg"
  ],
  "tags": [
    {"id": 1, "name": "friendly"},
    {"id": 2, "name": "trained"}
  ],
  "status": "available"
}

### Find pets by status
GET /petstore/pet/findByStatus?status=available

### Response (auto-generated array):
[
  {
    "id": 42,
    "name": "Buddy",
    "status": "available",
    ...
  },
  {
    "id": 43,
    "name": "Luna",
    "status": "available",
    ...
  }
]

स्कीमा

GET /api/openapi/specs/petstore

### Shows full details:
### - All endpoints
### - Load time
### - Context configuration
### - Base path

ओपन MAPI परिभाषा से सिस्टम अनुक्रिया निकालता है:

POST /api/openapi/specs/petstore/reload

वास्तविक विश्वव्यापी उपयोग

DELETE /api/openapi/specs/petstore

उदाहरण: पतझड़

चलो क्लासिक पतों का उपहास करने के माध्यम से चलते हैं:

### Load Petstore at /petstore
POST /api/openapi/specs
{"name": "petstore", "source": "...", "basePath": "/petstore"}

### Load GitHub API at /github
POST /api/openapi/specs
{"name": "github", "source": "...", "basePath": "/github"}

### Load Stripe API at /stripe
POST /api/openapi/specs
{"name": "stripe", "source": "...", "basePath": "/stripe"}

### All three APIs now available simultaneously:
GET /petstore/pet/123
GET /github/users/octocat
GET /stripe/customers/cus_123

चरण 1: स्पाइट लोड

अनुक्रिया:

POST /api/openapi/specs
Content-Type: application/json

{
  "name": "petstore",
  "source": "https://petstore3.swagger.io/api/v3/openapi.json",
  "basePath": "/petstore",
  "contextName": "petstore-session"
}

कदम 2: नकली अंत की बातों का इस्तेमाल करें

### Create a pet
POST /petstore/pet
{"name": "Max", "status": "available"}

### Response: {"id": 42, "name": "Max", "status": "available"}

### Get the pet (will reference same ID and name)
GET /petstore/pet/42

### Response: {"id": 42, "name": "Max", "status": "available"}
### Notice: Consistent ID and name from context

अब सभी 19 अंत - बिन्दु उपलब्ध हैं:

चरण 3: युक्ति का निरीक्षण करें

POST /api/openapi/test
Content-Type: application/json

{
  "specName": "petstore",
  "path": "/pet/123",
  "method": "GET"
}

### Returns mock response without affecting routes

चरण 4: री- लोड यदि स्पाइट परिवर्तन हों

• कदम 5: जब सम्पन्न हो जाए
• बहु स्पेक्टिकता
• आप एक साथ बहुत से परत लोड कर सकते हैं, प्रत्येक अपने बेस पथ के साथ:

संदर्भों के साथ युक्ति

अधिक वास्तविकवाद के लिए, एक परत के लिए संदर्भ निर्धारित करें:http://localhost:5116/OpenApi:

graph TD
    A[OpenAPI Manager UI] --> B[Load Spec Section]
    A --> C[Spec List]
    A --> D[Context Viewer]

    B --> E[URL Input]
    B --> F[JSON Input]
    B --> G[Context Configuration]

    C --> H[Spec Card]
    H --> I[Reload Button]
    H --> J[Delete Button]
    H --> K[View Endpoints]

    D --> L[Active Contexts]
    L --> M[Context Details]
    L --> N[Clear Context]

अब सभी पालतू बिन्दु एक ही संदर्भ में भाग लेते हैं:

• जाँच अंत बिन्दुजाँच अंत - बिन्दुओं के बिना आप वास्तविक निवेदन किए एक अंत बिन्दु की कोशिश करते हैं:
• **यह के लिए उपयोगी है:**एकीकरण से पहले जवाब पूर्वावलोकन
• पृथकता में विशिष्ट अंत क्षेत्रों पर जाँच की जा रही हैडिबगिंग स्कीमा मुद्दों को देख रहा है
• यूआई प्रबंधनदृश्य प्रबंधन के लिए, यात्रा
• **विशेषताएँ:**खींचें और ड्रॉप
• स्पेस फ़ाइल अपलोडजीव - विज्ञान खोज

- सभी अंत- बिन्दु तत्काल देखें

परीक्षणों के लिए एक-एक क्लिक करें

• कोई अंत बिन्दु बटन के साथ जाँच करें

# OpenAPI Spec
/pet/{petId}:
  get:
    parameters:
      - name: petId
        in: path
        schema:
          type: integer

GET /petstore/pet/123
### LLM receives: "Generate data for Pet with petId=123"
### Response: {"id": 123, ...}

रीयल- समय अधिसूचना

• सिग्नलआर अद्यतन जब स्पेस लोड हो

/pet/findByStatus:
  get:
    parameters:
      - name: status
        in: query
        schema:
          type: string
          enum: [available, pending, sold]

GET /petstore/pet/findByStatus?status=available
### LLM receives: "Generate array of Pets with status=available"
### Response: [{"status": "available", ...}, ...]

वाक्य रचना हाइलाइटिंग

• सुंदर JSON प्रतिक्रिया प्रदर्शन

/pet:
  post:
    requestBody:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Pet'

POST /petstore/pet
Content-Type: application/json

{"name": "Max", "status": "available"}

### LLM receives: "Generate response for creating Pet with name=Max, status=available"
### Response: {"id": 42, "name": "Max", "status": "available"}

कॉन्टेक्स्ट प्रबंधनComment

• दृश्य तथा साफ संदर्भ

/pet/{petId}:
  get:
    summary: Find pet by ID
    description: Returns a single pet based on the ID provided

विस्तृत विशेषताएँ

पथ पैरामीटर

पथ पैरामीटर्स स्वतः निकाले गए हैं:

responses:
  '200':
    description: Successful operation
    content:
      application/json:
        schema:
          $ref: '#/components/schemas/Pet'
  '404':
    description: Pet not found

क्वैरी पैरामीटर

क्वैरी पैरामीटर्स प्रतिक्रियाओं को प्रभावित करता है:

आग्रह करें...

public async Task NotifySpecLoaded(string name, string basePath)
{
    await _hubContext.Clients.All.SendAsync("SpecLoaded", new
    {
        name,
        basePath,
        timestamp = DateTimeOffset.UtcNow
    });
}

public async Task NotifySpecDeleted(string name)
{
    await _hubContext.Clients.All.SendAsync("SpecDeleted", new
    {
        name,
        timestamp = DateTimeOffset.UtcNow
    });
}

आउटपुट/ आउटपुट बॉडी को प्राम्प्ट में शामिल किया गया है:

const connection = new signalR.HubConnectionBuilder()
    .withUrl('/hubs/openapi')
    .build();

connection.on('SpecLoaded', (data) => {
    showNotification(`Spec "${data.name}" loaded at ${data.basePath}`, 'success');
    refreshSpecList();
});

connection.on('SpecDeleted', (data) => {
    showNotification(`Spec "${data.name}" deleted`, 'info');
    refreshSpecList();
});

वर्णन तथा सारस

GALLLL को निर्देशित करता है:

• इन मूल भाग में शामिल हैं, अंत- बिन्दुओं के उद्देश्य को समझने में मदद.
• अनुक्रिया स्थिति कोड
• तंत्र प्रथम सफल (xxx) प्रतिक्रिया उपयोग में आता है:
• सिर्फ 200 प्रसंगों का प्रयोग उपहास करने के लिए किया जाता है (404s वर्तमान में सिमुलेट नहीं कर रहे हैं).
• सिग्नल- आर वास्तविक समय अद्यतन

जब स्पेस लोड किया जाता है/ मिटाएँ, यूआई को सिग्नलआर से वास्तविक समय की सूचना प्राप्त होती है:

जावास्क्रिप्ट यूआई कोड:

फॉर्मेट समर्थन

 Bad:  {"name": "spec1", ...}
 Good: {"name": "github-v3", ...}

तंत्र समर्थन देता है:

खोलें.x

### Good separation
/petstore/...
/github/...
/stripe/...

### Bad (conflicts!)
/api/... (multiple specs)

ओपनपीआई 3. 1.x

स्विंगल 2. 0

POST /api/openapi/specs/my-api/reload

JSON प्रारूप

POST /api/openapi/specs
{
  "name": "petstore",
  "source": "...",
  "contextName": "test-session"
}

### Now all petstore calls maintain consistency

YAएमएल फ़ॉर्मेट

JSON तथा YAएमएल स्पेस स्वचालित रूप से पता लगाया जाता है और पार्स किया जाता है.

DELETE /api/openapi/specs/old-spec

बढ़िया अभ्यास

1. **1 ..**वर्णन्तम स्पिट्यूशन नाम इस्तेमाल करें
2. 2बेस बेस पथ सेट करें
3. **विशिष्ट बेस बेस पथों के उपयोग से विरोधाभासों से दूर रहें:**3
4. जब स्पाइट्स बदलता है तो री- लोड करेंयदि आपका ओपन- पीजीपी स्पेस अद्यतन किया जा रहा है, इसे फिर से लोड करें:
5. **4.**संबंधित कॉल के लिए संदर्भों का प्रयोग करें

5.

जाँच के बाद साफ करें/api/mockस्पेस जो आप अब इस्तेमाल नहीं कर रहे हैं उसे हटाएँ:

### OpenAPI-based (from spec)
GET /petstore/pet/123
### Uses Pet schema from OpenAPI spec

### Regular mock (shape-based)
GET /api/mock/custom?shape={"id":0,"name":"string"}
### Uses explicit shape parameter

सीमाएँ

अनुक्रिया स्थिति कोड

- केवल सफल (2xx) प्रतिक्रिया का उपहास किया जाता है

सत्यापन

private readonly ConcurrentDictionary<string, OpenApiSpecConfig> _specs = new();

- एक ज्ञात हेडर स्वीकार किया जाता है लेकिन वैध नहीं

DynamicOpenApiManagerवैधता

- स्कीमा के खिलाफ वैधीकरण लागू नहीं है

स्थिति

### Send these simultaneously
POST /api/openapi/specs {"name": "spec1", ...}
POST /api/openapi/specs {"name": "spec2", ...}
POST /api/openapi/specs {"name": "spec3", ...}

• कोई वास्तविक डाटाबेस नहीं; डाटा तैयार किया जाता है प्रत्येक बार (जब संदर्भों के उपयोग से संदर्भों का प्रयोग न हो)

परफार्मेंस

-LLM की पीढ़ी देर से आगे बढ़ती है (0-2100-00ms प्रति निवेदन)

नियमित रूप से नकली अंत - बिन्दुओं के साथ संगतिमैथ स्पेस्स नियमित के साथ कार्य करता है

अंत- बिन्दुएँ:

• दोनों ही मूल - तत्व का प्रयोग करते हैं लेकिन स्कीमा को कैसे प्रदान किया जाता है में भिन्‍न ।
• परफ़ॉर्मेंस ऑप्टीमाइज़ेशन
• कैशिंग
• लोड किए गए स्पेस को मेमोरी में कैश किया जाता है:

सेवा जीवन समय

**एक एकलटन है, तो कल्पना अनुप्रयोग जीवन के लिए लोड रहता है.**समानांतर युक्ति लोड किया जा रहा है

अनेक परत समानांतर में लोड की जा सकती है:

• सभी तीन समानांतर में लोड होगा, गंभीरता से नहीं./petstore + /pet/123 = /petstore/pet/123
• ट्रबलिंग
• युक्ति लोड नहीं है

समस्या:

युक्ति लोड करने में विफलसमाधानः

यूआरएल जिसे प्राप्त करना है उसकी जाँच करें

• फ़ाइल को सत्यापित करें (स्थानीय पथ के लिए)
• JSON/YAएमएल वैध है
• कोरस मुद्दों के लिए देखें ( रिमोट यूआरएल के लिए)

अंतिम बिन्दु नहीं मिला

समस्या:

उम्मीद की जाती है 404

• समाधानःबेस पथ सत्यापित करें:
• स्पेसर वास्तव में पारिभाषित करता है कि पथ जाँचेंएचटीटीपी विधि मिलान सुनिश्चित करें (जीटीएस vdit)
• अनुक्रिया योजना मिलान नहीं करता हैसमस्या:
• एसटीडी डाटा अपेक्षित स्कीमा से मेल नहीं खातासमाधानः
• जाँचें कि क्या स्पेस में स्कीमा सही हैसत्यापित करें कि आप सही प्रतिक्रिया देख रहे हैं (200sv1)

याद रखिए: कम - से - कम एक पीढ़ी में काफी सुधार आया है, न कि सही - गलत के बारे में

कंटेनमेंट