794 lines
23 KiB
Rust
794 lines
23 KiB
Rust
use crank_import::rest::{
|
|
ExternalDocumentSnapshot, ImportFindingSeverity, NormalizationConfig, NormalizedSchemaKind,
|
|
SourceDigest, external_reference_uris, normalize_verified_bundle, normalize_verified_document,
|
|
preview_from_ir, reference_uris,
|
|
};
|
|
|
|
fn digest(byte: char) -> SourceDigest {
|
|
SourceDigest::parse(byte.to_string().repeat(64)).unwrap()
|
|
}
|
|
|
|
fn normalize(document: &str) -> crank_import::rest::NormalizedIr {
|
|
normalize_verified_document(document, digest('a'), &NormalizationConfig::default()).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn resolves_local_schema_and_object_references_with_rfc6901_escaping() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Local refs }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items/{id}:
|
|
get:
|
|
operationId: getItem
|
|
parameters:
|
|
- { $ref: '#/components/parameters/Id' }
|
|
responses:
|
|
'200': { $ref: '#/components/responses/Ok' }
|
|
components:
|
|
parameters:
|
|
Id: { name: id, in: path, required: true, schema: { type: string } }
|
|
responses:
|
|
Ok:
|
|
description: ok
|
|
content:
|
|
application/json:
|
|
schema: { $ref: '#/components/schemas/a~1b~0c' }
|
|
schemas:
|
|
a/b~c:
|
|
type: object
|
|
required: [id]
|
|
properties: { id: { type: string } }
|
|
"#;
|
|
let ir = normalize(document);
|
|
let operation = &ir.operations[0];
|
|
assert_eq!(operation.parameters.len(), 1);
|
|
assert_eq!(operation.parameters[0].name, "id");
|
|
assert!(matches!(
|
|
operation.response_schema.as_ref().map(|schema| &schema.kind),
|
|
Some(NormalizedSchemaKind::Object { properties, .. }) if properties.contains_key("id")
|
|
));
|
|
assert!(ir.unresolved_references.is_empty());
|
|
assert_eq!(ir.reference_graph.edges.len(), 3);
|
|
assert!(
|
|
ir.findings
|
|
.iter()
|
|
.chain(operation.findings.iter())
|
|
.all(|finding| finding.code != "unresolved_reference")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn broken_reference_blocks_only_affected_candidate_and_full_preview_remains_visible() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Partial graph }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/broken:
|
|
get:
|
|
operationId: broken
|
|
responses:
|
|
'200':
|
|
description: nope
|
|
content: { application/json: { schema: { $ref: '#/components/schemas/Missing' } } }
|
|
/healthy:
|
|
get:
|
|
operationId: healthy
|
|
responses: { '204': { description: ok } }
|
|
"#;
|
|
let ir = normalize(document);
|
|
let broken = ir
|
|
.operations
|
|
.iter()
|
|
.find(|operation| operation.path == "/broken")
|
|
.unwrap();
|
|
let healthy = ir
|
|
.operations
|
|
.iter()
|
|
.find(|operation| operation.path == "/healthy")
|
|
.unwrap();
|
|
assert!(broken.findings.iter().any(|finding| {
|
|
finding.code == "reference_target_missing"
|
|
&& finding.severity == ImportFindingSeverity::Error
|
|
}));
|
|
assert!(healthy.findings.is_empty());
|
|
let preview = preview_from_ir(&ir);
|
|
assert_eq!(
|
|
preview
|
|
.groups
|
|
.iter()
|
|
.map(|group| group.operations.len())
|
|
.sum::<usize>(),
|
|
2
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn external_references_are_default_deny_without_network_or_snapshot() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: External deny }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
get:
|
|
operationId: listItems
|
|
responses:
|
|
'200':
|
|
description: ok
|
|
content: { application/json: { schema: { $ref: 'https://schemas.example.test/root.yaml#/Item' } } }
|
|
"#;
|
|
let ir = normalize(document);
|
|
assert!(
|
|
ir.operations[0]
|
|
.findings
|
|
.iter()
|
|
.any(|finding| finding.code == "external_reference_disabled")
|
|
);
|
|
assert!(ir.reference_graph.edges.is_empty());
|
|
assert!(ir.reference_graph.dependency_digests.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn resolves_supplied_external_snapshot_and_relative_chain_deterministically() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: External snapshots }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
get:
|
|
operationId: listItems
|
|
responses:
|
|
'200':
|
|
description: ok
|
|
content: { application/json: { schema: { $ref: 'https://schemas.example.test/root.yaml#/Item' } } }
|
|
"#;
|
|
let snapshots = vec![
|
|
ExternalDocumentSnapshot {
|
|
canonical_uri: "https://schemas.example.test/root.yaml".to_owned(),
|
|
digest: digest('b'),
|
|
document: "Item: { $ref: 'child.yaml#/Child' }".to_owned(),
|
|
},
|
|
ExternalDocumentSnapshot {
|
|
canonical_uri: "https://schemas.example.test/child.yaml".to_owned(),
|
|
digest: digest('c'),
|
|
document: "Child: { type: object, properties: { value: { type: integer } } }"
|
|
.to_owned(),
|
|
},
|
|
];
|
|
let first = normalize_verified_bundle(
|
|
document,
|
|
digest('a'),
|
|
&snapshots,
|
|
&NormalizationConfig::default(),
|
|
)
|
|
.unwrap();
|
|
let second = normalize_verified_bundle(
|
|
document,
|
|
digest('a'),
|
|
&snapshots,
|
|
&NormalizationConfig::default(),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
serde_json::to_vec(&first).unwrap(),
|
|
serde_json::to_vec(&second).unwrap()
|
|
);
|
|
assert_eq!(
|
|
first.reference_graph.dependency_digests,
|
|
vec![digest('b'), digest('c')]
|
|
);
|
|
assert_eq!(first.reference_graph.edges.len(), 2);
|
|
assert_eq!(
|
|
first.reference_graph.edges[1].source.snapshot_digest,
|
|
digest('b')
|
|
);
|
|
assert!(first.unresolved_references.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn recursion_is_a_stable_graph_edge_without_unbounded_expansion() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Recursive }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/nodes:
|
|
get:
|
|
operationId: getNode
|
|
responses:
|
|
'200':
|
|
description: ok
|
|
content: { application/json: { schema: { $ref: '#/components/schemas/Node' } } }
|
|
components:
|
|
schemas:
|
|
Node:
|
|
type: object
|
|
properties:
|
|
child: { $ref: '#/components/schemas/Node' }
|
|
"#;
|
|
let ir = normalize(document);
|
|
assert!(ir.reference_graph.edges.iter().any(|edge| edge.recursive));
|
|
assert!(ir.unresolved_references.is_empty());
|
|
assert!(
|
|
ir.operations[0]
|
|
.findings
|
|
.iter()
|
|
.all(|finding| finding.code != "reference_graph_limit")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn merges_compatible_all_of_and_blocks_conflicts_without_first_branch_loss() {
|
|
let compatible = r#"
|
|
openapi: 3.1.0
|
|
info: { title: AllOf }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
post:
|
|
operationId: createItem
|
|
requestBody:
|
|
content:
|
|
application/json:
|
|
schema:
|
|
allOf:
|
|
- { type: object, required: [id], properties: { id: { type: string } } }
|
|
- { type: object, required: [name], properties: { name: { type: string } } }
|
|
responses: { '204': { description: ok } }
|
|
"#;
|
|
let ir = normalize(compatible);
|
|
assert!(matches!(
|
|
ir.operations[0].request_body_schema.as_ref().map(|schema| &schema.kind),
|
|
Some(NormalizedSchemaKind::Object { properties, required })
|
|
if properties.len() == 2 && required == &vec!["id".to_owned(), "name".to_owned()]
|
|
));
|
|
|
|
let conflict = compatible.replace("{ name: { type: string } }", "{ id: { type: integer } }");
|
|
let ir = normalize(&conflict);
|
|
assert!(
|
|
ir.operations[0]
|
|
.findings
|
|
.iter()
|
|
.any(|finding| finding.code == "all_of_conflict")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn preserves_one_of_discriminator_and_projects_all_alternatives() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Alternatives }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/events:
|
|
post:
|
|
operationId: createEvent
|
|
requestBody:
|
|
content:
|
|
application/json:
|
|
schema:
|
|
discriminator:
|
|
propertyName: kind
|
|
mapping: { text: '#/components/schemas/Text' }
|
|
oneOf:
|
|
- { type: object, properties: { text: { type: string } } }
|
|
- { type: object, properties: { count: { type: integer } } }
|
|
responses: { '204': { description: ok } }
|
|
"#;
|
|
let ir = normalize(document);
|
|
let schema = ir.operations[0].request_body_schema.as_ref().unwrap();
|
|
assert_eq!(schema.discriminator.as_ref().unwrap().property_name, "kind");
|
|
assert!(matches!(
|
|
&schema.kind,
|
|
NormalizedSchemaKind::Composition { operator, variants }
|
|
if operator == "oneOf" && variants.len() == 2
|
|
));
|
|
let preview = preview_from_ir(&ir);
|
|
let candidate = &preview.groups[0].operations[0];
|
|
assert_eq!(
|
|
candidate
|
|
.draft
|
|
.input_schema
|
|
.fields
|
|
.get("body")
|
|
.unwrap()
|
|
.variants
|
|
.len(),
|
|
2
|
|
);
|
|
|
|
let any_of = document
|
|
.replace("discriminator:\n propertyName: kind\n mapping: { text: '#/components/schemas/Text' }\n oneOf:", "anyOf:");
|
|
let ir = normalize(&any_of);
|
|
assert!(matches!(
|
|
&ir.operations[0].request_body_schema.as_ref().unwrap().kind,
|
|
NormalizedSchemaKind::Composition { operator, variants }
|
|
if operator == "anyOf" && variants.len() == 2
|
|
));
|
|
let preview = preview_from_ir(&ir);
|
|
assert_eq!(
|
|
preview.groups[0].operations[0].draft.input_schema.fields["body"]
|
|
.variants
|
|
.len(),
|
|
2
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn oas_31_applies_ref_siblings_while_oas_30_ignores_them() {
|
|
let template = |version: &str| {
|
|
format!(
|
|
r#"
|
|
openapi: {version}
|
|
info: {{ title: Siblings }}
|
|
servers: [{{ url: https://api.example.test }}]
|
|
paths:
|
|
/items:
|
|
get:
|
|
operationId: listItems
|
|
responses:
|
|
'200':
|
|
description: ok
|
|
content:
|
|
application/json:
|
|
schema:
|
|
$ref: '#/components/schemas/Item'
|
|
description: sibling-description
|
|
components:
|
|
schemas:
|
|
Item: {{ type: string, description: target-description }}
|
|
"#
|
|
)
|
|
};
|
|
let v30 = normalize(&template("3.0.3"));
|
|
let v31 = normalize(&template("3.1.0"));
|
|
assert_eq!(
|
|
v30.operations[0]
|
|
.response_schema
|
|
.as_ref()
|
|
.unwrap()
|
|
.description
|
|
.as_deref(),
|
|
Some("target-description")
|
|
);
|
|
assert_eq!(
|
|
v31.operations[0]
|
|
.response_schema
|
|
.as_ref()
|
|
.unwrap()
|
|
.description
|
|
.as_deref(),
|
|
Some("sibling-description")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_pointer_and_type_mismatch_are_exact_blockers_without_panic() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Invalid targets }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/missing:
|
|
get:
|
|
operationId: missing
|
|
responses:
|
|
'200': { description: ok, content: { application/json: { schema: { $ref: '#not-a-pointer' } } } }
|
|
/scalar:
|
|
get:
|
|
operationId: scalar
|
|
responses:
|
|
'200': { description: ok, content: { application/json: { schema: { $ref: '#/info/title' } } } }
|
|
"#;
|
|
let ir = normalize(document);
|
|
let codes = ir
|
|
.operations
|
|
.iter()
|
|
.flat_map(|operation| {
|
|
operation
|
|
.findings
|
|
.iter()
|
|
.map(move |finding| (operation.path.as_str(), finding.code.as_str()))
|
|
})
|
|
.collect::<std::collections::BTreeSet<_>>();
|
|
assert!(codes.contains(&("/missing", "reference_target_missing")));
|
|
assert!(codes.contains(&("/scalar", "reference_type_mismatch")));
|
|
}
|
|
|
|
#[test]
|
|
fn reference_depth_and_expanded_node_limits_fail_closed() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Bounded }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
get:
|
|
operationId: listItems
|
|
responses:
|
|
'200': { description: ok, content: { application/json: { schema: { $ref: '#/components/schemas/A' } } } }
|
|
components:
|
|
schemas:
|
|
A: { $ref: '#/components/schemas/B' }
|
|
B: { $ref: '#/components/schemas/C' }
|
|
C: { type: object, properties: { id: { type: string } } }
|
|
"#;
|
|
let config = NormalizationConfig {
|
|
max_reference_depth: 1,
|
|
..NormalizationConfig::default()
|
|
};
|
|
let ir = normalize_verified_document(document, digest('a'), &config).unwrap();
|
|
assert!(
|
|
ir.operations
|
|
.iter()
|
|
.flat_map(|operation| &operation.findings)
|
|
.any(|finding| finding.code == "reference_graph_limit")
|
|
);
|
|
|
|
let config = NormalizationConfig {
|
|
max_expanded_nodes: 8,
|
|
..NormalizationConfig::default()
|
|
};
|
|
let ir = normalize_verified_document(document, digest('a'), &config).unwrap();
|
|
assert!(
|
|
ir.findings
|
|
.iter()
|
|
.chain(
|
|
ir.operations
|
|
.iter()
|
|
.flat_map(|operation| &operation.findings)
|
|
)
|
|
.any(|finding| finding.code == "reference_graph_limit")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_discriminator_and_multiple_composition_operators_are_blockers() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Unsupported composition }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/events:
|
|
post:
|
|
operationId: createEvent
|
|
requestBody:
|
|
content:
|
|
application/json:
|
|
schema:
|
|
discriminator: { mapping: { bad: 42 } }
|
|
oneOf: [{ type: string }, { type: integer }]
|
|
anyOf: [{ type: boolean }, { type: string }]
|
|
responses: { '204': { description: ok } }
|
|
"#;
|
|
let ir = normalize(document);
|
|
let codes = ir.operations[0]
|
|
.findings
|
|
.iter()
|
|
.map(|finding| finding.code.as_str())
|
|
.collect::<std::collections::BTreeSet<_>>();
|
|
assert!(codes.contains("unsupported_discriminator"));
|
|
assert!(codes.contains("unsupported_composition"));
|
|
}
|
|
|
|
#[test]
|
|
fn reference_uri_scan_applies_external_size_depth_and_alias_limits_before_traversal() {
|
|
let config = NormalizationConfig {
|
|
max_bytes: 8,
|
|
max_external_document_bytes: 8,
|
|
..NormalizationConfig::default()
|
|
};
|
|
assert_eq!(
|
|
reference_uris("external-document", &config),
|
|
Err(crank_import::rest::ImportParseError::LimitExceeded)
|
|
);
|
|
|
|
let config = NormalizationConfig {
|
|
max_bytes: 8,
|
|
max_external_document_bytes: 32,
|
|
..NormalizationConfig::default()
|
|
};
|
|
assert_eq!(
|
|
external_reference_uris("external-document", &config),
|
|
Ok(Vec::new())
|
|
);
|
|
|
|
let config = NormalizationConfig {
|
|
max_depth: 1,
|
|
..NormalizationConfig::default()
|
|
};
|
|
assert_eq!(
|
|
reference_uris("a: { b: { $ref: '#/x' } }", &config),
|
|
Err(crank_import::rest::ImportParseError::LimitExceeded)
|
|
);
|
|
|
|
let aliases = format!(
|
|
"items: [{}]",
|
|
std::iter::repeat_n("*a", 129)
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
);
|
|
assert_eq!(
|
|
reference_uris(&aliases, &NormalizationConfig::default()),
|
|
Err(crank_import::rest::ImportParseError::LimitExceeded)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn resolves_relative_references_using_rfc3986_paths_and_decoded_fragments() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Relative refs }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
get:
|
|
operationId: listItems
|
|
responses:
|
|
'200':
|
|
description: ok
|
|
content: { application/json: { schema: { $ref: 'HTTPS://SCHEMAS.EXAMPLE.TEST:443/a/b/root.yaml#/Item' } } }
|
|
"#;
|
|
let snapshots = vec![
|
|
ExternalDocumentSnapshot {
|
|
canonical_uri: "https://schemas.example.test/a/b/root.yaml".to_owned(),
|
|
digest: digest('b'),
|
|
document: r#"
|
|
Item:
|
|
type: object
|
|
properties:
|
|
dot: { $ref: './child.yaml#/Value' }
|
|
parent: { $ref: '../common.yaml#/Value' }
|
|
absolute: { $ref: '/shared.yaml#/Value' }
|
|
"#
|
|
.to_owned(),
|
|
},
|
|
ExternalDocumentSnapshot {
|
|
canonical_uri: "https://schemas.example.test/a/b/child.yaml".to_owned(),
|
|
digest: digest('c'),
|
|
document: "Value: { type: string }".to_owned(),
|
|
},
|
|
ExternalDocumentSnapshot {
|
|
canonical_uri: "https://schemas.example.test/a/common.yaml".to_owned(),
|
|
digest: digest('d'),
|
|
document: "Value: { type: integer }".to_owned(),
|
|
},
|
|
ExternalDocumentSnapshot {
|
|
canonical_uri: "https://schemas.example.test/shared.yaml".to_owned(),
|
|
digest: digest('e'),
|
|
document: "Value: { $ref: '#/a%7E1b' }\na/b: { type: boolean }".to_owned(),
|
|
},
|
|
];
|
|
let ir = normalize_verified_bundle(
|
|
document,
|
|
digest('a'),
|
|
&snapshots,
|
|
&NormalizationConfig::default(),
|
|
)
|
|
.unwrap();
|
|
let Some(NormalizedSchemaKind::Object { properties, .. }) = ir.operations[0]
|
|
.response_schema
|
|
.as_ref()
|
|
.map(|schema| &schema.kind)
|
|
else {
|
|
panic!("response should be an expanded object schema");
|
|
};
|
|
assert_eq!(properties.len(), 3);
|
|
assert_eq!(ir.reference_graph.edges.len(), 5);
|
|
assert!(ir.findings.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_percent_encoded_fragment_is_a_blocker() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Malformed reference }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
get:
|
|
operationId: listItems
|
|
responses:
|
|
'200': { description: ok, content: { application/json: { schema: { $ref: '#/components/%ZZ' } } } }
|
|
"#;
|
|
let ir = normalize(document);
|
|
assert!(
|
|
ir.operations[0]
|
|
.findings
|
|
.iter()
|
|
.any(|finding| finding.code == "reference_uri_malformed")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn does_not_follow_references_inside_literal_payloads() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Literal payloads }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
get:
|
|
operationId: listItems
|
|
responses:
|
|
'200':
|
|
description: ok
|
|
content:
|
|
application/json:
|
|
schema:
|
|
type: object
|
|
example: { $ref: '#/components/schemas/Missing' }
|
|
examples: { sample: { value: { $ref: '#/components/schemas/Missing' } } }
|
|
default: { $ref: '#/components/schemas/Missing' }
|
|
enum: [{ $ref: '#/components/schemas/Missing' }]
|
|
const: { $ref: '#/components/schemas/Missing' }
|
|
x-fixture: { $ref: '#/components/schemas/Missing' }
|
|
properties: { known: { $ref: '#/components/schemas/Known' } }
|
|
components:
|
|
schemas:
|
|
Known: { type: string }
|
|
"#;
|
|
assert_eq!(
|
|
reference_uris(document, &NormalizationConfig::default()),
|
|
Ok(vec!["#/components/schemas/Known".to_owned()])
|
|
);
|
|
let ir = normalize(document);
|
|
assert_eq!(ir.reference_graph.edges.len(), 1);
|
|
assert!(
|
|
ir.operations[0]
|
|
.findings
|
|
.iter()
|
|
.all(|finding| finding.code != "reference_target_missing")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn primary_oas31_applies_ref_siblings_in_external_snapshots_without_openapi_field() {
|
|
let source = |version: &str| {
|
|
format!(
|
|
r#"
|
|
openapi: {version}
|
|
info: {{ title: External siblings }}
|
|
servers: [{{ url: https://api.example.test }}]
|
|
paths:
|
|
/items:
|
|
get:
|
|
operationId: listItems
|
|
responses:
|
|
'200': {{ description: ok, content: {{ application/json: {{ schema: {{ $ref: 'https://schemas.example.test/root.yaml#/Item' }} }} }} }}
|
|
"#
|
|
)
|
|
};
|
|
let snapshots = vec![
|
|
ExternalDocumentSnapshot {
|
|
canonical_uri: "https://schemas.example.test/root.yaml".to_owned(),
|
|
digest: digest('b'),
|
|
document: "Item: { $ref: 'child.yaml#/Base', description: sibling }".to_owned(),
|
|
},
|
|
ExternalDocumentSnapshot {
|
|
canonical_uri: "https://schemas.example.test/child.yaml".to_owned(),
|
|
digest: digest('c'),
|
|
document: "Base: { type: string, description: target }".to_owned(),
|
|
},
|
|
];
|
|
let v31 = normalize_verified_bundle(
|
|
&source("3.1.0"),
|
|
digest('a'),
|
|
&snapshots,
|
|
&NormalizationConfig::default(),
|
|
)
|
|
.unwrap();
|
|
let v30 = normalize_verified_bundle(
|
|
&source("3.0.3"),
|
|
digest('a'),
|
|
&snapshots,
|
|
&NormalizationConfig::default(),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
v31.operations[0]
|
|
.response_schema
|
|
.as_ref()
|
|
.unwrap()
|
|
.description
|
|
.as_deref(),
|
|
Some("sibling")
|
|
);
|
|
assert_eq!(
|
|
v30.operations[0]
|
|
.response_schema
|
|
.as_ref()
|
|
.unwrap()
|
|
.description
|
|
.as_deref(),
|
|
Some("target")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn all_of_intersects_constraints_and_nested_properties_without_losing_conflicts() {
|
|
let source = r#"
|
|
openapi: 3.1.0
|
|
info: { title: allOf intersections }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
post:
|
|
operationId: createItem
|
|
requestBody:
|
|
content:
|
|
application/json:
|
|
schema:
|
|
allOf:
|
|
- type: object
|
|
minimum: 1
|
|
maximum: 10
|
|
minLength: 2
|
|
maxLength: 12
|
|
properties: { nested: { type: object, properties: { left: { type: string } } } }
|
|
- type: object
|
|
minimum: 4
|
|
maximum: 8
|
|
minLength: 5
|
|
maxLength: 9
|
|
properties: { nested: { type: object, properties: { right: { type: integer } } } }
|
|
responses: { '204': { description: ok } }
|
|
"#;
|
|
let ir = normalize(source);
|
|
let schema = ir.operations[0].request_body_schema.as_ref().unwrap();
|
|
assert_eq!(schema.constraints.minimum, Some(4.0));
|
|
assert_eq!(schema.constraints.maximum, Some(8.0));
|
|
assert_eq!(schema.constraints.min_length, Some(5));
|
|
assert_eq!(schema.constraints.max_length, Some(9));
|
|
let NormalizedSchemaKind::Object { properties, .. } = &schema.kind else {
|
|
panic!("merged schema should remain an object");
|
|
};
|
|
let NormalizedSchemaKind::Object { properties, .. } = &properties["nested"].kind else {
|
|
panic!("nested property should remain an object");
|
|
};
|
|
assert!(properties.contains_key("left") && properties.contains_key("right"));
|
|
|
|
let conflicting = source.replace("maximum: 8", "maximum: 3");
|
|
let ir = normalize(&conflicting);
|
|
assert!(
|
|
ir.operations[0]
|
|
.findings
|
|
.iter()
|
|
.any(|finding| finding.code == "all_of_conflict")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn non_array_all_of_is_preserved_and_reported() {
|
|
let document = r#"
|
|
openapi: 3.1.0
|
|
info: { title: Invalid allOf }
|
|
servers: [{ url: https://api.example.test }]
|
|
paths:
|
|
/items:
|
|
post:
|
|
operationId: createItem
|
|
requestBody:
|
|
content: { application/json: { schema: { allOf: { type: string } } } }
|
|
responses: { '204': { description: ok } }
|
|
"#;
|
|
let ir = normalize(document);
|
|
assert!(
|
|
ir.operations[0]
|
|
.findings
|
|
.iter()
|
|
.any(|finding| finding.code == "unsupported_composition")
|
|
);
|
|
assert!(matches!(
|
|
ir.operations[0]
|
|
.request_body_schema
|
|
.as_ref()
|
|
.map(|schema| &schema.kind),
|
|
Some(NormalizedSchemaKind::Unknown)
|
|
));
|
|
}
|