آزمایش API با شبیه سازی جلد 2

{
    name: "create activity",
    testFunc: func(t *testing.T, client *ClientWithResponses) {
        var (
            ctx     = context.Background()
            id      = int32(1)
            title   = randomTitleForResource("activity")
            dueDate = time.Now()
        )

        resp, err := client.PostApiV1ActivitiesWithApplicationJSONV10BodyWithResponse(
            ctx,
            PostApiV1ActivitiesApplicationJSONV10RequestBody{
                Id:        tests.ToPtr(id),
                Title:     tests.ToPtr(title),
                DueDate:   tests.ToPtr(dueDate),
                Completed: tests.ToPtr(false),
            },
        )
        require.NoError(t, err)
        require.NotNil(t, resp, "expected resp, got nil")
        require.NotNil(t, resp.ApplicationjsonV10200, "expected resp body, got nil")

        assert.Equal(t, http.StatusOK, resp.StatusCode())
        assert.Equal(t, id, *resp.ApplicationjsonV10200.Id)
        assert.Equal(t, title, *resp.ApplicationjsonV10200.Title)
        assert.Equal(
            t,
            dueDate.UTC().Format(time.RFC3339),
            resp.ApplicationjsonV10200.DueDate.UTC().Format(time.RFC3339),
        )
        assert.Equal(t, false, *resp.ApplicationjsonV10200.Completed)
    },
}

// Generate a random title to test the possibility of random data in Hoverfly
func randomTitleForResource(resource string) string {
    return fmt.Sprintf("%s-%s-title-%s", fakePrefix, resource, tests.RandomString(5))
}

{
    name: "create activity with UUID in title",
    testFunc: func(t *testing.T, client *ClientWithResponses) {
        ctx := context.Background()

        // Create multiple activities with different UUIDs
        for i := 0; i < 3; i++ {
            id := int32(1 + i)
            title := uuid.New().String()

            resp, err := client.PostApiV1ActivitiesWithApplicationJSONV10BodyWithResponse(
                ctx,
                PostApiV1ActivitiesApplicationJSONV10RequestBody{
                    Id:        tests.ToPtr(id),
                    Title:     tests.ToPtr(title),
                    DueDate:   tests.ToPtr(time.Now()),
                    Completed: tests.ToPtr(false),
                },
            )
            require.NoError(t, err)
            require.NotNil(t, resp)
            require.NotNil(t, resp.ApplicationjsonV10200)
            assert.Equal(t, http.StatusOK, resp.StatusCode())
            assert.NotNil(t, resp.ApplicationjsonV10200)
            assert.Equal(t, title, *resp.ApplicationjsonV10200.Title)
        }
    },
}

{
  "request": {
    "path": [
      {
        "matcher": "exact",
        "value": "/api/v1/Activities/1"
      }
    ],
    "method": [
      {
        "matcher": "exact",
        "value": "GET"
      }
    ],
    "destination": [
      {
        "matcher": "exact",
        "value": "fakerestapi.azurewebsites.net"
      }
    ],
    "scheme": [
      {
        "matcher": "exact",
        "value": "https"
      }
    ],
    "body": [
      {
        "matcher": "exact",
        "value": ""
      }
    ]
  },
  "response": {
    "status": 200,
    "body": "{\"id\":1,\"title\":\"Activity 1\",\"dueDate\":\"2025-03-04T23:24:16.4781493+00:00\",\"completed\":false}",
    "encodedBody": false,
    "headers": {
      "Api-Supported-Versions": [
        "1.0"
      ],
      "Content-Type": [
        "application/json; charset=utf-8; v=1.0"
      ],
      "Date": [
        "Tue, 04 Mar 2025 22:24:15 GMT"
      ],
      "Hoverfly": [
        "Was-Here"
      ],
      "Server": [
        "Kestrel"
      ]
    },
    "templated": false
  }
}

"response": {
  "status": 200,
  "body": "You requested: {{ Request.Path.[0].Value }}",
  "encodedBody": false,
  "headers": {
    "Content-Type": ["text/plain"]
  },
  "templated": true
}

version: "1.0"
settings:
  debug: false

patterns:
  # All UUIDs will be replaced with the default regex pattern
  - type: "uuid"

  # Dates will be replaced
  - type: "datetime"
    formats:
      - "2006-01-02T15:04:05Z07:00"
      - "2006-01-02"

  # Prefix matching
  - type: "prefix"
    pattern: "fake-api-test-"
    length: 5

endpoints:
  # Replace the response of the endpoint with the static_response
  - method: "GET"
    path: "/api/v1/Activities/30"
    status: 200
    static_response: |
      {
        "id": 77,
        "title": "John Doe",
        "dueDate": "2025-02-19T17:12:52.127Z",
        "completed": false
      }

func (p *PostProcessor) Process(simulation *v2.SimulationViewV5) error {
    if simulation == nil {
        return fmt.Errorf("nil simulation provided")
    }

    for i := range simulation.RequestResponsePairs {
        pair := &simulation.RequestResponsePairs[i]

        // 1. Check if this is a static endpoint rule
        if p.endpointProcessor != nil {
            if rule := p.endpointProcessor.FindMatchingRule(pair); rule != nil {
                if err := p.endpointProcessor.ApplyRule(pair, rule); err != nil {
                    return fmt.Errorf("applying static response for pair %d: %w", i, err)
                }
                continue
            }
        }

        // 2. Process the pair
        if err := p.processingStrategy.Process(pair); err != nil {
            return fmt.Errorf("processing pair %d: %w", i, err)
        }
    }

    return nil
}

func (p *PrefixProcessor) ProcessRequest(value string) (string, bool) {
    if p.replaceWith != "" {
        return p.replaceWith, true
    }

    // Properly escape any regex special characters in the prefix
    escapedPrefix := regexp.QuoteMeta(p.prefix)

    // Check if we detected a resource name embedded in the value
    if resourceName := p.detectResourceName(value); resourceName != "" {
        p.includeResourceName = true
        p.resourceName = resourceName

        // Pattern with resource name included
        return fmt.Sprintf("%s%s-[a-zA-Z0-9]{%d}", escapedPrefix, resourceName, p.randomLength), true
    }

    // Standard pattern without resource name
    return fmt.Sprintf("%s[a-zA-Z0-9]{%d}", escapedPrefix, p.randomLength), true
}

func (p *PrefixProcessor) ProcessResponse(field string, value string, modifiedFields map[string]bool) (string, bool) {
    if !p.Match(value) {
        return value, false
    }

    // If this field was modified in the request and no fixed replacement
    if modifiedFields[field] && p.replaceWith == "" {
        return fmt.Sprintf("{{ Request.Body 'jsonpath' '$.%s' }}", field), true
    }

    if p.replaceWith != "" {
        return p.replaceWith, true
    }

    return value, false
}

func (p *UUIDProcessor) ProcessRequest(_ string) (string, bool) {
    if p.replaceWith != "" {
        return p.replaceWith, true
    }
    // Use proper regex pattern for UUIDs that will work with Hoverfly's RegexMatch
    return `[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}`, true
}

func (p *UUIDProcessor) ProcessResponse(field string, value string, modifiedFields map[string]bool) (string, bool) {
    if !p.Match(value) {
        return value, false
    }

    // If we have a fixed replacement, use it regardless of modified fields
    if p.replaceWith != "" {
        return p.replaceWith, true
    }

    // If this field was modified in the request and modifiedFields is provided
    if modifiedFields != nil && modifiedFields[field] {
        return fmt.Sprintf("{{ Request.Body 'jsonpath' '$.%s' }}", field), true
    }

    return value, false
}

// Process handles both the request and response processing for a pair
func (s *DefaultProcessingStrategy) Process(pair *v2.RequestMatcherResponsePairViewV5) error {
    // First try to process the request
    modifiedFields, err := s.ProcessRequest(pair)
    if err != nil {
        return err
    }

    // Then process the response
    if len(modifiedFields) > 0 {
        // If we modified fields in the request, process response with them
        if err = s.ProcessResponse(pair, modifiedFields); err != nil {
            return err
        }
        return nil
    }

    // If we didn't modify any request fields (e.g., no request body or no matches),
    // try to process the response independently
    if err = s.processResponseForRequestsWithoutBody(pair); err != nil {
        return err
    }

    return nil
}

func (ts *TestServer) handleGetActivity(w http.ResponseWriter, r *http.Request) {
    attempt := ts.attempts.Add(1)

    // Extract the id from the URL path
    pathParts := strings.Split(r.URL.Path, "https://dev.to/")
    if len(pathParts) < 5 {
        http.Error(w, "Invalid URL", http.StatusBadRequest)
        return
    }
    idStr := pathParts[4]
    id, err := strconv.Atoi(idStr)
    if err != nil {
        http.Error(w, "Invalid ID", http.StatusBadRequest)
        return
    }

    // Simulate different responses based on attempt number
    switch attempt {
    case 1:
        // First attempt - Service Unavailable
        w.WriteHeader(http.StatusServiceUnavailable)
        json.NewEncoder(w).Encode(map[string]string{
            "error": "Service Temporarily Unavailable",
            "code":  "SERVER_BUSY",
        })
    case 2:
        // Second attempt - Gateway Timeout
        w.WriteHeader(http.StatusGatewayTimeout)
    case 3:
        // Third attempt - Success
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)
        _ = json.NewEncoder(w).Encode(map[string]interface{}{
            "id":        int32(id),
            "title":     "Test Activity",
            "dueDate":   "2025-02-20T09:58:59.009Z",
            "completed": false,
        })
    default:
        // Any subsequent attempts - Bad Request
        w.WriteHeader(http.StatusTooManyRequests)
        _ = json.NewEncoder(w).Encode(map[string]string{
            "error": "Too many attempts",
        })
    }
}

hoverctl mode capture --stateful

func TestActivitiesWithRetries(t *testing.T) {
    serverUrl, ok := os.LookupEnv("API_SERVER_URL")
    if !ok || serverUrl == "" {
        ts := tests.NewTestServer() // Start our test server
        defer ts.Close()
        serverUrl = ts.URL()
    }

    httpClient := tests.NewHttpClient(t)
    client, err := NewClientWithResponses(serverUrl, WithHTTPClient(httpClient))
    if err != nil {
        t.Fatalf("failed to inistialize client: %v", err)
    }
    defer func() {
        // Reset the server state
        _, _ = httpClient.Post(serverUrl+"/reset", "application/json", nil)
    }()

    scenarios := []testCase{
        {
            name: "create activity with retries",
            testFunc: func(t *testing.T, client *ClientWithResponses) {
                var (
                    ctx   = context.Background()
                    id    = int32(7474)
                    title = "Test Activity"
                )

                var lastErr error
                for attempt := 1; attempt <= 4; attempt++ {
                    resp, err := client.GetApiV1ActivitiesIdWithResponse(
                        ctx,
                        id,
                    )
                    if err != nil {
                        lastErr = err
                        continue
                    }

                    // Success!
                    if resp.StatusCode() == http.StatusOK {
                        require.NotNil(t, resp.ApplicationjsonV10200)
                        assert.Equal(t, id, *resp.ApplicationjsonV10200.Id)
                        assert.Equal(t, title, *resp.ApplicationjsonV10200.Title)
                        return
                    }

                    // Continue if it's a retryable status
                    if resp.StatusCode() == http.StatusServiceUnavailable ||
                        resp.StatusCode() == http.StatusGatewayTimeout {
                        continue
                    }

                    // Non-retryable error
                    t.Fatalf("Got non-retryable status: %d", resp.StatusCode())
                }

                // If we got here, all retries failed
                t.Fatalf("All retries failed. Last error: %v", lastErr)
            },
        },
    }

    for _, tt := range scenarios {
        t.Run(tt.name, func(t *testing.T) {
            tt.testFunc(t, client)
        })
    }
}

endpoints:
  - method: "GET"
    path: "/api/v1/Activities/30"
    status: 200
    static_response: |
      {
        "id": 77,
        "title": "John Doe",
        "dueDate": "2025-02-19T17:12:52.127Z",
        "completed": false
      }