mockforge_bench/conformance/
spec_driven.rs

1//! Spec-driven conformance testing
2//!
3//! Analyzes the user's OpenAPI spec to determine which features their API uses,
4//! then generates k6 conformance tests against their real endpoints.
5
6use super::generator::ConformanceConfig;
7use super::schema_validator::SchemaValidatorGenerator;
8use super::spec::ConformanceFeature;
9use crate::error::Result;
10use crate::request_gen::RequestGenerator;
11use crate::spec_parser::ApiOperation;
12use openapiv3::{
13    OpenAPI, Operation, Parameter, ParameterSchemaOrContent, ReferenceOr, RequestBody, Response,
14    Schema, SchemaKind, SecurityScheme, StringFormat, Type, VariantOrUnknownOrEmpty,
15};
16use std::collections::HashSet;
17
18/// Resolve `$ref` references against the OpenAPI components
19mod ref_resolver {
20    use super::*;
21
22    pub fn resolve_parameter<'a>(
23        param_ref: &'a ReferenceOr<Parameter>,
24        spec: &'a OpenAPI,
25    ) -> Option<&'a Parameter> {
26        match param_ref {
27            ReferenceOr::Item(param) => Some(param),
28            ReferenceOr::Reference { reference } => {
29                let name = reference.strip_prefix("#/components/parameters/")?;
30                let components = spec.components.as_ref()?;
31                match components.parameters.get(name)? {
32                    ReferenceOr::Item(param) => Some(param),
33                    ReferenceOr::Reference { .. } => None, // No recursive ref chasing
34                }
35            }
36        }
37    }
38
39    pub fn resolve_request_body<'a>(
40        body_ref: &'a ReferenceOr<RequestBody>,
41        spec: &'a OpenAPI,
42    ) -> Option<&'a RequestBody> {
43        match body_ref {
44            ReferenceOr::Item(body) => Some(body),
45            ReferenceOr::Reference { reference } => {
46                let name = reference.strip_prefix("#/components/requestBodies/")?;
47                let components = spec.components.as_ref()?;
48                match components.request_bodies.get(name)? {
49                    ReferenceOr::Item(body) => Some(body),
50                    ReferenceOr::Reference { .. } => None,
51                }
52            }
53        }
54    }
55
56    pub fn resolve_schema<'a>(
57        schema_ref: &'a ReferenceOr<Schema>,
58        spec: &'a OpenAPI,
59    ) -> Option<&'a Schema> {
60        resolve_schema_with_visited(schema_ref, spec, &mut HashSet::new())
61    }
62
63    fn resolve_schema_with_visited<'a>(
64        schema_ref: &'a ReferenceOr<Schema>,
65        spec: &'a OpenAPI,
66        visited: &mut HashSet<String>,
67    ) -> Option<&'a Schema> {
68        match schema_ref {
69            ReferenceOr::Item(schema) => Some(schema),
70            ReferenceOr::Reference { reference } => {
71                if !visited.insert(reference.clone()) {
72                    return None; // Cycle detected
73                }
74                let name = reference.strip_prefix("#/components/schemas/")?;
75                let components = spec.components.as_ref()?;
76                let nested = components.schemas.get(name)?;
77                resolve_schema_with_visited(nested, spec, visited)
78            }
79        }
80    }
81
82    /// Resolve a boxed schema reference (used by array items and object properties)
83    pub fn resolve_boxed_schema<'a>(
84        schema_ref: &'a ReferenceOr<Box<Schema>>,
85        spec: &'a OpenAPI,
86    ) -> Option<&'a Schema> {
87        match schema_ref {
88            ReferenceOr::Item(schema) => Some(schema.as_ref()),
89            ReferenceOr::Reference { reference } => {
90                // Delegate to the regular schema resolver
91                let name = reference.strip_prefix("#/components/schemas/")?;
92                let components = spec.components.as_ref()?;
93                let nested = components.schemas.get(name)?;
94                resolve_schema_with_visited(nested, spec, &mut HashSet::new())
95            }
96        }
97    }
98
99    pub fn resolve_response<'a>(
100        resp_ref: &'a ReferenceOr<Response>,
101        spec: &'a OpenAPI,
102    ) -> Option<&'a Response> {
103        match resp_ref {
104            ReferenceOr::Item(resp) => Some(resp),
105            ReferenceOr::Reference { reference } => {
106                let name = reference.strip_prefix("#/components/responses/")?;
107                let components = spec.components.as_ref()?;
108                match components.responses.get(name)? {
109                    ReferenceOr::Item(resp) => Some(resp),
110                    ReferenceOr::Reference { .. } => None,
111                }
112            }
113        }
114    }
115}
116
117/// An API operation annotated with the conformance features it exercises
118#[derive(Debug, Clone)]
119pub struct AnnotatedOperation {
120    pub path: String,
121    pub method: String,
122    pub features: Vec<ConformanceFeature>,
123    pub request_body_content_type: Option<String>,
124    pub sample_body: Option<String>,
125    pub query_params: Vec<(String, String)>,
126    pub header_params: Vec<(String, String)>,
127    pub path_params: Vec<(String, String)>,
128    /// Response schema for validation (JSON string of the schema)
129    pub response_schema: Option<Schema>,
130}
131
132/// Generates spec-driven conformance k6 scripts
133pub struct SpecDrivenConformanceGenerator {
134    config: ConformanceConfig,
135    operations: Vec<AnnotatedOperation>,
136}
137
138impl SpecDrivenConformanceGenerator {
139    pub fn new(config: ConformanceConfig, operations: Vec<AnnotatedOperation>) -> Self {
140        Self { config, operations }
141    }
142
143    /// Annotate a list of API operations with conformance features
144    pub fn annotate_operations(
145        operations: &[ApiOperation],
146        spec: &OpenAPI,
147    ) -> Vec<AnnotatedOperation> {
148        operations.iter().map(|op| Self::annotate_operation(op, spec)).collect()
149    }
150
151    /// Analyze an operation and determine which conformance features it exercises
152    fn annotate_operation(op: &ApiOperation, spec: &OpenAPI) -> AnnotatedOperation {
153        let mut features = Vec::new();
154        let mut query_params = Vec::new();
155        let mut header_params = Vec::new();
156        let mut path_params = Vec::new();
157
158        // Detect HTTP method feature
159        match op.method.to_uppercase().as_str() {
160            "GET" => features.push(ConformanceFeature::MethodGet),
161            "POST" => features.push(ConformanceFeature::MethodPost),
162            "PUT" => features.push(ConformanceFeature::MethodPut),
163            "PATCH" => features.push(ConformanceFeature::MethodPatch),
164            "DELETE" => features.push(ConformanceFeature::MethodDelete),
165            "HEAD" => features.push(ConformanceFeature::MethodHead),
166            "OPTIONS" => features.push(ConformanceFeature::MethodOptions),
167            _ => {}
168        }
169
170        // Detect parameter features (resolves $ref)
171        for param_ref in &op.operation.parameters {
172            if let Some(param) = ref_resolver::resolve_parameter(param_ref, spec) {
173                Self::annotate_parameter(
174                    param,
175                    spec,
176                    &mut features,
177                    &mut query_params,
178                    &mut header_params,
179                    &mut path_params,
180                );
181            }
182        }
183
184        // Detect path parameters from the path template itself
185        for segment in op.path.split('/') {
186            if segment.starts_with('{') && segment.ends_with('}') {
187                let name = &segment[1..segment.len() - 1];
188                // Only add if not already found from parameters
189                if !path_params.iter().any(|(n, _)| n == name) {
190                    path_params.push((name.to_string(), "test-value".to_string()));
191                    // Determine type from path params we didn't already handle
192                    if !features.contains(&ConformanceFeature::PathParamString)
193                        && !features.contains(&ConformanceFeature::PathParamInteger)
194                    {
195                        features.push(ConformanceFeature::PathParamString);
196                    }
197                }
198            }
199        }
200
201        // Detect request body features (resolves $ref)
202        let mut request_body_content_type = None;
203        let mut sample_body = None;
204
205        let resolved_body = op
206            .operation
207            .request_body
208            .as_ref()
209            .and_then(|b| ref_resolver::resolve_request_body(b, spec));
210
211        if let Some(body) = resolved_body {
212            for (content_type, _media) in &body.content {
213                match content_type.as_str() {
214                    "application/json" => {
215                        features.push(ConformanceFeature::BodyJson);
216                        request_body_content_type = Some("application/json".to_string());
217                        // Generate sample body from schema
218                        if let Ok(template) = RequestGenerator::generate_template(op) {
219                            if let Some(body_val) = &template.body {
220                                sample_body = Some(body_val.to_string());
221                            }
222                        }
223                    }
224                    "application/x-www-form-urlencoded" => {
225                        features.push(ConformanceFeature::BodyFormUrlencoded);
226                        request_body_content_type =
227                            Some("application/x-www-form-urlencoded".to_string());
228                    }
229                    "multipart/form-data" => {
230                        features.push(ConformanceFeature::BodyMultipart);
231                        request_body_content_type = Some("multipart/form-data".to_string());
232                    }
233                    _ => {}
234                }
235            }
236
237            // Detect schema features in request body (resolves $ref in schema)
238            if let Some(media) = body.content.get("application/json") {
239                if let Some(schema_ref) = &media.schema {
240                    if let Some(schema) = ref_resolver::resolve_schema(schema_ref, spec) {
241                        Self::annotate_schema(schema, spec, &mut features);
242                    }
243                }
244            }
245        }
246
247        // Detect response code features
248        Self::annotate_responses(&op.operation, spec, &mut features);
249
250        // Extract response schema for validation (resolves $ref)
251        let response_schema = Self::extract_response_schema(&op.operation, spec);
252        if response_schema.is_some() {
253            features.push(ConformanceFeature::ResponseValidation);
254        }
255
256        // Detect content negotiation (response with multiple content types)
257        Self::annotate_content_negotiation(&op.operation, spec, &mut features);
258
259        // Detect security features
260        Self::annotate_security(&op.operation, spec, &mut features);
261
262        // Deduplicate features
263        features.sort_by_key(|f| f.check_name());
264        features.dedup_by_key(|f| f.check_name());
265
266        AnnotatedOperation {
267            path: op.path.clone(),
268            method: op.method.to_uppercase(),
269            features,
270            request_body_content_type,
271            sample_body,
272            query_params,
273            header_params,
274            path_params,
275            response_schema,
276        }
277    }
278
279    /// Annotate parameter features
280    fn annotate_parameter(
281        param: &Parameter,
282        spec: &OpenAPI,
283        features: &mut Vec<ConformanceFeature>,
284        query_params: &mut Vec<(String, String)>,
285        header_params: &mut Vec<(String, String)>,
286        path_params: &mut Vec<(String, String)>,
287    ) {
288        let (location, data) = match param {
289            Parameter::Query { parameter_data, .. } => ("query", parameter_data),
290            Parameter::Path { parameter_data, .. } => ("path", parameter_data),
291            Parameter::Header { parameter_data, .. } => ("header", parameter_data),
292            Parameter::Cookie { .. } => {
293                features.push(ConformanceFeature::CookieParam);
294                return;
295            }
296        };
297
298        // Detect type from schema
299        let is_integer = Self::param_schema_is_integer(data, spec);
300        let is_array = Self::param_schema_is_array(data, spec);
301
302        // Generate sample value
303        let sample = if is_integer {
304            "42".to_string()
305        } else if is_array {
306            "a,b".to_string()
307        } else {
308            "test-value".to_string()
309        };
310
311        match location {
312            "path" => {
313                if is_integer {
314                    features.push(ConformanceFeature::PathParamInteger);
315                } else {
316                    features.push(ConformanceFeature::PathParamString);
317                }
318                path_params.push((data.name.clone(), sample));
319            }
320            "query" => {
321                if is_array {
322                    features.push(ConformanceFeature::QueryParamArray);
323                } else if is_integer {
324                    features.push(ConformanceFeature::QueryParamInteger);
325                } else {
326                    features.push(ConformanceFeature::QueryParamString);
327                }
328                query_params.push((data.name.clone(), sample));
329            }
330            "header" => {
331                features.push(ConformanceFeature::HeaderParam);
332                header_params.push((data.name.clone(), sample));
333            }
334            _ => {}
335        }
336
337        // Check for constraint features on the parameter (resolves $ref)
338        if let ParameterSchemaOrContent::Schema(schema_ref) = &data.format {
339            if let Some(schema) = ref_resolver::resolve_schema(schema_ref, spec) {
340                Self::annotate_schema(schema, spec, features);
341            }
342        }
343
344        // Required/optional
345        if data.required {
346            features.push(ConformanceFeature::ConstraintRequired);
347        } else {
348            features.push(ConformanceFeature::ConstraintOptional);
349        }
350    }
351
352    fn param_schema_is_integer(data: &openapiv3::ParameterData, spec: &OpenAPI) -> bool {
353        if let ParameterSchemaOrContent::Schema(schema_ref) = &data.format {
354            if let Some(schema) = ref_resolver::resolve_schema(schema_ref, spec) {
355                return matches!(&schema.schema_kind, SchemaKind::Type(Type::Integer(_)));
356            }
357        }
358        false
359    }
360
361    fn param_schema_is_array(data: &openapiv3::ParameterData, spec: &OpenAPI) -> bool {
362        if let ParameterSchemaOrContent::Schema(schema_ref) = &data.format {
363            if let Some(schema) = ref_resolver::resolve_schema(schema_ref, spec) {
364                return matches!(&schema.schema_kind, SchemaKind::Type(Type::Array(_)));
365            }
366        }
367        false
368    }
369
370    /// Annotate schema-level features (types, composition, formats, constraints)
371    fn annotate_schema(schema: &Schema, spec: &OpenAPI, features: &mut Vec<ConformanceFeature>) {
372        match &schema.schema_kind {
373            SchemaKind::Type(Type::String(s)) => {
374                features.push(ConformanceFeature::SchemaString);
375                // Check format
376                match &s.format {
377                    VariantOrUnknownOrEmpty::Item(StringFormat::Date) => {
378                        features.push(ConformanceFeature::FormatDate);
379                    }
380                    VariantOrUnknownOrEmpty::Item(StringFormat::DateTime) => {
381                        features.push(ConformanceFeature::FormatDateTime);
382                    }
383                    VariantOrUnknownOrEmpty::Unknown(fmt) => match fmt.as_str() {
384                        "email" => features.push(ConformanceFeature::FormatEmail),
385                        "uuid" => features.push(ConformanceFeature::FormatUuid),
386                        "uri" | "url" => features.push(ConformanceFeature::FormatUri),
387                        "ipv4" => features.push(ConformanceFeature::FormatIpv4),
388                        "ipv6" => features.push(ConformanceFeature::FormatIpv6),
389                        _ => {}
390                    },
391                    _ => {}
392                }
393                // Check constraints
394                if s.pattern.is_some() {
395                    features.push(ConformanceFeature::ConstraintPattern);
396                }
397                if !s.enumeration.is_empty() {
398                    features.push(ConformanceFeature::ConstraintEnum);
399                }
400                if s.min_length.is_some() || s.max_length.is_some() {
401                    features.push(ConformanceFeature::ConstraintMinMax);
402                }
403            }
404            SchemaKind::Type(Type::Integer(i)) => {
405                features.push(ConformanceFeature::SchemaInteger);
406                if i.minimum.is_some() || i.maximum.is_some() {
407                    features.push(ConformanceFeature::ConstraintMinMax);
408                }
409                if !i.enumeration.is_empty() {
410                    features.push(ConformanceFeature::ConstraintEnum);
411                }
412            }
413            SchemaKind::Type(Type::Number(n)) => {
414                features.push(ConformanceFeature::SchemaNumber);
415                if n.minimum.is_some() || n.maximum.is_some() {
416                    features.push(ConformanceFeature::ConstraintMinMax);
417                }
418            }
419            SchemaKind::Type(Type::Boolean(_)) => {
420                features.push(ConformanceFeature::SchemaBoolean);
421            }
422            SchemaKind::Type(Type::Array(arr)) => {
423                features.push(ConformanceFeature::SchemaArray);
424                if let Some(item_ref) = &arr.items {
425                    if let Some(item_schema) = ref_resolver::resolve_boxed_schema(item_ref, spec) {
426                        Self::annotate_schema(item_schema, spec, features);
427                    }
428                }
429            }
430            SchemaKind::Type(Type::Object(obj)) => {
431                features.push(ConformanceFeature::SchemaObject);
432                // Check required fields
433                if !obj.required.is_empty() {
434                    features.push(ConformanceFeature::ConstraintRequired);
435                }
436                // Walk properties (resolves $ref)
437                for (_name, prop_ref) in &obj.properties {
438                    if let Some(prop_schema) = ref_resolver::resolve_boxed_schema(prop_ref, spec) {
439                        Self::annotate_schema(prop_schema, spec, features);
440                    }
441                }
442            }
443            SchemaKind::OneOf { .. } => {
444                features.push(ConformanceFeature::CompositionOneOf);
445            }
446            SchemaKind::AnyOf { .. } => {
447                features.push(ConformanceFeature::CompositionAnyOf);
448            }
449            SchemaKind::AllOf { .. } => {
450                features.push(ConformanceFeature::CompositionAllOf);
451            }
452            _ => {}
453        }
454    }
455
456    /// Detect response code features (resolves $ref in responses)
457    fn annotate_responses(
458        operation: &Operation,
459        spec: &OpenAPI,
460        features: &mut Vec<ConformanceFeature>,
461    ) {
462        for (status_code, resp_ref) in &operation.responses.responses {
463            // Only count features for responses that actually resolve
464            if ref_resolver::resolve_response(resp_ref, spec).is_some() {
465                match status_code {
466                    openapiv3::StatusCode::Code(200) => {
467                        features.push(ConformanceFeature::Response200)
468                    }
469                    openapiv3::StatusCode::Code(201) => {
470                        features.push(ConformanceFeature::Response201)
471                    }
472                    openapiv3::StatusCode::Code(204) => {
473                        features.push(ConformanceFeature::Response204)
474                    }
475                    openapiv3::StatusCode::Code(400) => {
476                        features.push(ConformanceFeature::Response400)
477                    }
478                    openapiv3::StatusCode::Code(404) => {
479                        features.push(ConformanceFeature::Response404)
480                    }
481                    _ => {}
482                }
483            }
484        }
485    }
486
487    /// Extract the response schema for the primary success response (200 or 201)
488    /// Resolves $ref for both the response and the schema within it.
489    fn extract_response_schema(operation: &Operation, spec: &OpenAPI) -> Option<Schema> {
490        // Try 200 first, then 201
491        for code in [200u16, 201] {
492            if let Some(resp_ref) =
493                operation.responses.responses.get(&openapiv3::StatusCode::Code(code))
494            {
495                if let Some(response) = ref_resolver::resolve_response(resp_ref, spec) {
496                    if let Some(media) = response.content.get("application/json") {
497                        if let Some(schema_ref) = &media.schema {
498                            if let Some(schema) = ref_resolver::resolve_schema(schema_ref, spec) {
499                                return Some(schema.clone());
500                            }
501                        }
502                    }
503                }
504            }
505        }
506        None
507    }
508
509    /// Detect content negotiation: response supports multiple content types
510    fn annotate_content_negotiation(
511        operation: &Operation,
512        spec: &OpenAPI,
513        features: &mut Vec<ConformanceFeature>,
514    ) {
515        for (_status_code, resp_ref) in &operation.responses.responses {
516            if let Some(response) = ref_resolver::resolve_response(resp_ref, spec) {
517                if response.content.len() > 1 {
518                    features.push(ConformanceFeature::ContentNegotiation);
519                    return; // Only need to detect once per operation
520                }
521            }
522        }
523    }
524
525    /// Detect security scheme features.
526    /// Checks operation-level security first, falling back to global security requirements.
527    /// Resolves scheme names against SecurityScheme definitions in components.
528    fn annotate_security(
529        operation: &Operation,
530        spec: &OpenAPI,
531        features: &mut Vec<ConformanceFeature>,
532    ) {
533        // Use operation-level security if present, otherwise fall back to global
534        let security_reqs = operation.security.as_ref().or(spec.security.as_ref());
535
536        if let Some(security) = security_reqs {
537            for security_req in security {
538                for scheme_name in security_req.keys() {
539                    // Try to resolve the scheme from components for accurate type detection
540                    if let Some(resolved) = Self::resolve_security_scheme(scheme_name, spec) {
541                        match resolved {
542                            SecurityScheme::HTTP { ref scheme, .. } => {
543                                if scheme.eq_ignore_ascii_case("bearer") {
544                                    features.push(ConformanceFeature::SecurityBearer);
545                                } else if scheme.eq_ignore_ascii_case("basic") {
546                                    features.push(ConformanceFeature::SecurityBasic);
547                                }
548                            }
549                            SecurityScheme::APIKey { .. } => {
550                                features.push(ConformanceFeature::SecurityApiKey);
551                            }
552                            // OAuth2 and OpenIDConnect don't map to our current feature set
553                            _ => {}
554                        }
555                    } else {
556                        // Fallback: heuristic name matching for unresolvable schemes
557                        let name_lower = scheme_name.to_lowercase();
558                        if name_lower.contains("bearer") || name_lower.contains("jwt") {
559                            features.push(ConformanceFeature::SecurityBearer);
560                        } else if name_lower.contains("api") && name_lower.contains("key") {
561                            features.push(ConformanceFeature::SecurityApiKey);
562                        } else if name_lower.contains("basic") {
563                            features.push(ConformanceFeature::SecurityBasic);
564                        }
565                    }
566                }
567            }
568        }
569    }
570
571    /// Resolve a security scheme name to its SecurityScheme definition
572    fn resolve_security_scheme<'a>(name: &str, spec: &'a OpenAPI) -> Option<&'a SecurityScheme> {
573        let components = spec.components.as_ref()?;
574        match components.security_schemes.get(name)? {
575            ReferenceOr::Item(scheme) => Some(scheme),
576            ReferenceOr::Reference { .. } => None,
577        }
578    }
579
580    /// Generate the k6 conformance script
581    pub fn generate(&self) -> Result<String> {
582        let mut script = String::with_capacity(16384);
583
584        // Imports
585        script.push_str("import http from 'k6/http';\n");
586        script.push_str("import { check, group } from 'k6';\n\n");
587
588        // Options
589        script.push_str("export const options = {\n");
590        script.push_str("  vus: 1,\n");
591        script.push_str("  iterations: 1,\n");
592        if self.config.skip_tls_verify {
593            script.push_str("  insecureSkipTLSVerify: true,\n");
594        }
595        script.push_str("  thresholds: {\n");
596        script.push_str("    checks: ['rate>0'],\n");
597        script.push_str("  },\n");
598        script.push_str("};\n\n");
599
600        // Base URL
601        script.push_str(&format!("const BASE_URL = '{}';\n\n", self.config.target_url));
602        script.push_str("const JSON_HEADERS = { 'Content-Type': 'application/json' };\n\n");
603
604        // Default function
605        script.push_str("export default function () {\n");
606
607        // Group operations by category
608        let mut category_ops: std::collections::BTreeMap<
609            &'static str,
610            Vec<(&AnnotatedOperation, &ConformanceFeature)>,
611        > = std::collections::BTreeMap::new();
612
613        for op in &self.operations {
614            for feature in &op.features {
615                let category = feature.category();
616                if self.config.should_include_category(category) {
617                    category_ops.entry(category).or_default().push((op, feature));
618                }
619            }
620        }
621
622        // Emit grouped tests
623        for (category, ops) in &category_ops {
624            script.push_str(&format!("  group('{}', function () {{\n", category));
625
626            // Track which check names we've already emitted to avoid duplicates
627            let mut emitted_checks: std::collections::HashSet<&str> =
628                std::collections::HashSet::new();
629
630            for (op, feature) in ops {
631                if !emitted_checks.insert(feature.check_name()) {
632                    continue; // Skip duplicate check names
633                }
634
635                self.emit_check(&mut script, op, feature);
636            }
637
638            script.push_str("  });\n\n");
639        }
640
641        script.push_str("}\n\n");
642
643        // handleSummary
644        self.generate_handle_summary(&mut script);
645
646        Ok(script)
647    }
648
649    /// Emit a single k6 check for an operation + feature
650    fn emit_check(
651        &self,
652        script: &mut String,
653        op: &AnnotatedOperation,
654        feature: &ConformanceFeature,
655    ) {
656        script.push_str("    {\n");
657
658        // Build the URL path with parameters substituted
659        let mut url_path = op.path.clone();
660        for (name, value) in &op.path_params {
661            url_path = url_path.replace(&format!("{{{}}}", name), value);
662        }
663
664        // Build query string
665        if !op.query_params.is_empty() {
666            let qs: Vec<String> =
667                op.query_params.iter().map(|(k, v)| format!("{}={}", k, v)).collect();
668            url_path = format!("{}?{}", url_path, qs.join("&"));
669        }
670
671        let full_url = format!("${{BASE_URL}}{}", url_path);
672
673        // Determine HTTP method and emit request
674        match op.method.as_str() {
675            "GET" => {
676                if !op.header_params.is_empty() {
677                    let headers_obj = Self::format_headers(&op.header_params);
678                    script.push_str(&format!(
679                        "      let res = http.get(`{}`, {{ headers: {} }});\n",
680                        full_url, headers_obj
681                    ));
682                } else {
683                    script.push_str(&format!("      let res = http.get(`{}`);\n", full_url));
684                }
685            }
686            "POST" => {
687                self.emit_request_with_body(script, "post", &full_url, op);
688            }
689            "PUT" => {
690                self.emit_request_with_body(script, "put", &full_url, op);
691            }
692            "PATCH" => {
693                self.emit_request_with_body(script, "patch", &full_url, op);
694            }
695            "DELETE" => {
696                script.push_str(&format!("      let res = http.del(`{}`);\n", full_url));
697            }
698            "HEAD" => {
699                script.push_str(&format!("      let res = http.head(`{}`);\n", full_url));
700            }
701            "OPTIONS" => {
702                script.push_str(&format!("      let res = http.options(`{}`);\n", full_url));
703            }
704            _ => {
705                script.push_str(&format!("      let res = http.get(`{}`);\n", full_url));
706            }
707        }
708
709        // Check: emit assertion based on feature type
710        let check_name = feature.check_name();
711        if matches!(
712            feature,
713            ConformanceFeature::Response200
714                | ConformanceFeature::Response201
715                | ConformanceFeature::Response204
716                | ConformanceFeature::Response400
717                | ConformanceFeature::Response404
718        ) {
719            let expected_code = match feature {
720                ConformanceFeature::Response200 => 200,
721                ConformanceFeature::Response201 => 201,
722                ConformanceFeature::Response204 => 204,
723                ConformanceFeature::Response400 => 400,
724                ConformanceFeature::Response404 => 404,
725                _ => 200,
726            };
727            script.push_str(&format!(
728                "      check(res, {{ '{}': (r) => r.status === {} }});\n",
729                check_name, expected_code
730            ));
731        } else if matches!(feature, ConformanceFeature::ResponseValidation) {
732            // Response schema validation — validate the response body against the schema
733            if let Some(schema) = &op.response_schema {
734                let validation_js = SchemaValidatorGenerator::generate_validation(schema);
735                script.push_str(&format!(
736                    "      try {{ let body = res.json(); check(res, {{ '{}': (r) => {{ {} }} }}); }} catch(e) {{ check(res, {{ '{}': () => false }}); }}\n",
737                    check_name, validation_js, check_name
738                ));
739            }
740        } else {
741            script.push_str(&format!(
742                "      check(res, {{ '{}': (r) => r.status >= 200 && r.status < 500 }});\n",
743                check_name
744            ));
745        }
746
747        script.push_str("    }\n");
748    }
749
750    /// Emit an HTTP request with a body
751    fn emit_request_with_body(
752        &self,
753        script: &mut String,
754        method: &str,
755        url: &str,
756        op: &AnnotatedOperation,
757    ) {
758        if let Some(body) = &op.sample_body {
759            let escaped_body = body.replace('\'', "\\'");
760            let mut headers = "JSON_HEADERS".to_string();
761            if !op.header_params.is_empty() {
762                headers = format!(
763                    "Object.assign({{}}, JSON_HEADERS, {})",
764                    Self::format_headers(&op.header_params)
765                );
766            }
767            script.push_str(&format!(
768                "      let res = http.{}(`{}`, '{}', {{ headers: {} }});\n",
769                method, url, escaped_body, headers
770            ));
771        } else {
772            script.push_str(&format!("      let res = http.{}(`{}`, null);\n", method, url));
773        }
774    }
775
776    /// Format header params as a JS object literal
777    fn format_headers(headers: &[(String, String)]) -> String {
778        let entries: Vec<String> =
779            headers.iter().map(|(k, v)| format!("'{}': '{}'", k, v)).collect();
780        format!("{{ {} }}", entries.join(", "))
781    }
782
783    /// handleSummary — same format as reference mode for report compatibility
784    fn generate_handle_summary(&self, script: &mut String) {
785        script.push_str("export function handleSummary(data) {\n");
786        script.push_str("  let checks = {};\n");
787        script.push_str("  if (data.metrics && data.metrics.checks) {\n");
788        script.push_str("    checks.overall_pass_rate = data.metrics.checks.values.rate;\n");
789        script.push_str("  }\n");
790        script.push_str("  let checkResults = {};\n");
791        script.push_str("  function walkGroups(group) {\n");
792        script.push_str("    if (group.checks) {\n");
793        script.push_str("      for (let checkObj of group.checks) {\n");
794        script.push_str("        checkResults[checkObj.name] = {\n");
795        script.push_str("          passes: checkObj.passes,\n");
796        script.push_str("          fails: checkObj.fails,\n");
797        script.push_str("        };\n");
798        script.push_str("      }\n");
799        script.push_str("    }\n");
800        script.push_str("    if (group.groups) {\n");
801        script.push_str("      for (let subGroup of group.groups) {\n");
802        script.push_str("        walkGroups(subGroup);\n");
803        script.push_str("      }\n");
804        script.push_str("    }\n");
805        script.push_str("  }\n");
806        script.push_str("  if (data.root_group) {\n");
807        script.push_str("    walkGroups(data.root_group);\n");
808        script.push_str("  }\n");
809        script.push_str("  return {\n");
810        script.push_str("    'conformance-report.json': JSON.stringify({ checks: checkResults, overall: checks }, null, 2),\n");
811        script.push_str("    stdout: textSummary(data, { indent: '  ', enableColors: true }),\n");
812        script.push_str("  };\n");
813        script.push_str("}\n\n");
814        script.push_str("function textSummary(data, opts) {\n");
815        script.push_str("  return JSON.stringify(data, null, 2);\n");
816        script.push_str("}\n");
817    }
818}
819
820#[cfg(test)]
821mod tests {
822    use super::*;
823    use openapiv3::{
824        Operation, ParameterData, ParameterSchemaOrContent, PathStyle, Response, Schema,
825        SchemaData, SchemaKind, StringType, Type,
826    };
827
828    fn make_op(method: &str, path: &str, operation: Operation) -> ApiOperation {
829        ApiOperation {
830            method: method.to_string(),
831            path: path.to_string(),
832            operation,
833            operation_id: None,
834        }
835    }
836
837    fn empty_spec() -> OpenAPI {
838        OpenAPI::default()
839    }
840
841    #[test]
842    fn test_annotate_get_with_path_param() {
843        let mut op = Operation::default();
844        op.parameters.push(ReferenceOr::Item(Parameter::Path {
845            parameter_data: ParameterData {
846                name: "id".to_string(),
847                description: None,
848                required: true,
849                deprecated: None,
850                format: ParameterSchemaOrContent::Schema(ReferenceOr::Item(Schema {
851                    schema_data: SchemaData::default(),
852                    schema_kind: SchemaKind::Type(Type::String(StringType::default())),
853                })),
854                example: None,
855                examples: Default::default(),
856                explode: None,
857                extensions: Default::default(),
858            },
859            style: PathStyle::Simple,
860        }));
861
862        let api_op = make_op("get", "/users/{id}", op);
863        let annotated = SpecDrivenConformanceGenerator::annotate_operation(&api_op, &empty_spec());
864
865        assert!(annotated.features.contains(&ConformanceFeature::MethodGet));
866        assert!(annotated.features.contains(&ConformanceFeature::PathParamString));
867        assert!(annotated.features.contains(&ConformanceFeature::ConstraintRequired));
868        assert_eq!(annotated.path_params.len(), 1);
869        assert_eq!(annotated.path_params[0].0, "id");
870    }
871
872    #[test]
873    fn test_annotate_post_with_json_body() {
874        let mut op = Operation::default();
875        let mut body = openapiv3::RequestBody::default();
876        body.required = true;
877        body.content
878            .insert("application/json".to_string(), openapiv3::MediaType::default());
879        op.request_body = Some(ReferenceOr::Item(body));
880
881        let api_op = make_op("post", "/items", op);
882        let annotated = SpecDrivenConformanceGenerator::annotate_operation(&api_op, &empty_spec());
883
884        assert!(annotated.features.contains(&ConformanceFeature::MethodPost));
885        assert!(annotated.features.contains(&ConformanceFeature::BodyJson));
886    }
887
888    #[test]
889    fn test_annotate_response_codes() {
890        let mut op = Operation::default();
891        op.responses
892            .responses
893            .insert(openapiv3::StatusCode::Code(200), ReferenceOr::Item(Response::default()));
894        op.responses
895            .responses
896            .insert(openapiv3::StatusCode::Code(404), ReferenceOr::Item(Response::default()));
897
898        let api_op = make_op("get", "/items", op);
899        let annotated = SpecDrivenConformanceGenerator::annotate_operation(&api_op, &empty_spec());
900
901        assert!(annotated.features.contains(&ConformanceFeature::Response200));
902        assert!(annotated.features.contains(&ConformanceFeature::Response404));
903    }
904
905    #[test]
906    fn test_generate_spec_driven_script() {
907        let config = ConformanceConfig {
908            target_url: "http://localhost:3000".to_string(),
909            api_key: None,
910            basic_auth: None,
911            skip_tls_verify: false,
912            categories: None,
913        };
914
915        let operations = vec![AnnotatedOperation {
916            path: "/users/{id}".to_string(),
917            method: "GET".to_string(),
918            features: vec![
919                ConformanceFeature::MethodGet,
920                ConformanceFeature::PathParamString,
921            ],
922            request_body_content_type: None,
923            sample_body: None,
924            query_params: vec![],
925            header_params: vec![],
926            path_params: vec![("id".to_string(), "test-value".to_string())],
927            response_schema: None,
928        }];
929
930        let gen = SpecDrivenConformanceGenerator::new(config, operations);
931        let script = gen.generate().unwrap();
932
933        assert!(script.contains("import http from 'k6/http'"));
934        assert!(script.contains("/users/test-value"));
935        assert!(script.contains("param:path:string"));
936        assert!(script.contains("method:GET"));
937        assert!(script.contains("handleSummary"));
938    }
939
940    #[test]
941    fn test_generate_with_category_filter() {
942        let config = ConformanceConfig {
943            target_url: "http://localhost:3000".to_string(),
944            api_key: None,
945            basic_auth: None,
946            skip_tls_verify: false,
947            categories: Some(vec!["Parameters".to_string()]),
948        };
949
950        let operations = vec![AnnotatedOperation {
951            path: "/users/{id}".to_string(),
952            method: "GET".to_string(),
953            features: vec![
954                ConformanceFeature::MethodGet,
955                ConformanceFeature::PathParamString,
956            ],
957            request_body_content_type: None,
958            sample_body: None,
959            query_params: vec![],
960            header_params: vec![],
961            path_params: vec![("id".to_string(), "1".to_string())],
962            response_schema: None,
963        }];
964
965        let gen = SpecDrivenConformanceGenerator::new(config, operations);
966        let script = gen.generate().unwrap();
967
968        assert!(script.contains("group('Parameters'"));
969        assert!(!script.contains("group('HTTP Methods'"));
970    }
971
972    #[test]
973    fn test_annotate_response_validation() {
974        use openapiv3::ObjectType;
975
976        // Operation with a 200 response that has a JSON schema
977        let mut op = Operation::default();
978        let mut response = Response::default();
979        let mut media = openapiv3::MediaType::default();
980        let mut obj_type = ObjectType::default();
981        obj_type.properties.insert(
982            "name".to_string(),
983            ReferenceOr::Item(Box::new(Schema {
984                schema_data: SchemaData::default(),
985                schema_kind: SchemaKind::Type(Type::String(StringType::default())),
986            })),
987        );
988        obj_type.required = vec!["name".to_string()];
989        media.schema = Some(ReferenceOr::Item(Schema {
990            schema_data: SchemaData::default(),
991            schema_kind: SchemaKind::Type(Type::Object(obj_type)),
992        }));
993        response.content.insert("application/json".to_string(), media);
994        op.responses
995            .responses
996            .insert(openapiv3::StatusCode::Code(200), ReferenceOr::Item(response));
997
998        let api_op = make_op("get", "/users", op);
999        let annotated = SpecDrivenConformanceGenerator::annotate_operation(&api_op, &empty_spec());
1000
1001        assert!(
1002            annotated.features.contains(&ConformanceFeature::ResponseValidation),
1003            "Should detect ResponseValidation when response has a JSON schema"
1004        );
1005        assert!(annotated.response_schema.is_some(), "Should extract the response schema");
1006
1007        // Verify generated script includes schema validation with try-catch
1008        let config = ConformanceConfig {
1009            target_url: "http://localhost:3000".to_string(),
1010            api_key: None,
1011            basic_auth: None,
1012            skip_tls_verify: false,
1013            categories: None,
1014        };
1015        let gen = SpecDrivenConformanceGenerator::new(config, vec![annotated]);
1016        let script = gen.generate().unwrap();
1017
1018        assert!(
1019            script.contains("response:schema:validation"),
1020            "Script should contain the validation check name"
1021        );
1022        assert!(script.contains("try {"), "Script should wrap validation in try-catch");
1023        assert!(script.contains("res.json()"), "Script should parse response as JSON");
1024    }
1025
1026    #[test]
1027    fn test_annotate_global_security() {
1028        // Spec with global security requirement, operation without its own security
1029        let op = Operation::default();
1030        let mut spec = OpenAPI::default();
1031        let mut global_req = openapiv3::SecurityRequirement::new();
1032        global_req.insert("bearerAuth".to_string(), vec![]);
1033        spec.security = Some(vec![global_req]);
1034        // Define the security scheme in components
1035        let mut components = openapiv3::Components::default();
1036        components.security_schemes.insert(
1037            "bearerAuth".to_string(),
1038            ReferenceOr::Item(SecurityScheme::HTTP {
1039                scheme: "bearer".to_string(),
1040                bearer_format: Some("JWT".to_string()),
1041                description: None,
1042                extensions: Default::default(),
1043            }),
1044        );
1045        spec.components = Some(components);
1046
1047        let api_op = make_op("get", "/protected", op);
1048        let annotated = SpecDrivenConformanceGenerator::annotate_operation(&api_op, &spec);
1049
1050        assert!(
1051            annotated.features.contains(&ConformanceFeature::SecurityBearer),
1052            "Should detect SecurityBearer from global security + components"
1053        );
1054    }
1055
1056    #[test]
1057    fn test_annotate_security_scheme_resolution() {
1058        // Test that security scheme type is resolved from components, not just name heuristic
1059        let mut op = Operation::default();
1060        // Use a generic name that wouldn't match name heuristics
1061        let mut req = openapiv3::SecurityRequirement::new();
1062        req.insert("myAuth".to_string(), vec![]);
1063        op.security = Some(vec![req]);
1064
1065        let mut spec = OpenAPI::default();
1066        let mut components = openapiv3::Components::default();
1067        components.security_schemes.insert(
1068            "myAuth".to_string(),
1069            ReferenceOr::Item(SecurityScheme::APIKey {
1070                location: openapiv3::APIKeyLocation::Header,
1071                name: "X-API-Key".to_string(),
1072                description: None,
1073                extensions: Default::default(),
1074            }),
1075        );
1076        spec.components = Some(components);
1077
1078        let api_op = make_op("get", "/data", op);
1079        let annotated = SpecDrivenConformanceGenerator::annotate_operation(&api_op, &spec);
1080
1081        assert!(
1082            annotated.features.contains(&ConformanceFeature::SecurityApiKey),
1083            "Should detect SecurityApiKey from SecurityScheme::APIKey, not name heuristic"
1084        );
1085    }
1086
1087    #[test]
1088    fn test_annotate_content_negotiation() {
1089        let mut op = Operation::default();
1090        let mut response = Response::default();
1091        // Response with multiple content types
1092        response
1093            .content
1094            .insert("application/json".to_string(), openapiv3::MediaType::default());
1095        response
1096            .content
1097            .insert("application/xml".to_string(), openapiv3::MediaType::default());
1098        op.responses
1099            .responses
1100            .insert(openapiv3::StatusCode::Code(200), ReferenceOr::Item(response));
1101
1102        let api_op = make_op("get", "/items", op);
1103        let annotated = SpecDrivenConformanceGenerator::annotate_operation(&api_op, &empty_spec());
1104
1105        assert!(
1106            annotated.features.contains(&ConformanceFeature::ContentNegotiation),
1107            "Should detect ContentNegotiation when response has multiple content types"
1108        );
1109    }
1110
1111    #[test]
1112    fn test_no_content_negotiation_for_single_type() {
1113        let mut op = Operation::default();
1114        let mut response = Response::default();
1115        response
1116            .content
1117            .insert("application/json".to_string(), openapiv3::MediaType::default());
1118        op.responses
1119            .responses
1120            .insert(openapiv3::StatusCode::Code(200), ReferenceOr::Item(response));
1121
1122        let api_op = make_op("get", "/items", op);
1123        let annotated = SpecDrivenConformanceGenerator::annotate_operation(&api_op, &empty_spec());
1124
1125        assert!(
1126            !annotated.features.contains(&ConformanceFeature::ContentNegotiation),
1127            "Should NOT detect ContentNegotiation for a single content type"
1128        );
1129    }
1130}
mockforge_bench/conformance/spec_driven.rs

mockforge_bench/conformance/
spec_driven.rs
