//! Swagger 2.0 → OpenAPI 3.0 normalisation.

//!

//! Rather than teach every downstream module two spec dialects, a 2.0 document

//! is rewritten into the 3.0 shape as it's parsed ([`super::loader::parse_spec`]

//! calls [`to_openapi3`]), so `import`, `examples` and `docs` only ever see

//! 3.x. The conversion is structural and lossy in the places 3.0 has no slot

//! for — see the module's `convert_*` docs.

use serde_json::{Map, Value};

use super::resolve::deref;

const METHODS: [&str; 7] = ["get", "post", "put", "patch", "delete", "head", "options"];

/// Keys 2.0 puts directly on a non-body parameter (or a response header) that

/// 3.0 nests under `schema`.

const SCHEMA_KEYS: [&str; 16] = [

    "type",

    "format",

    "items",

    "default",

    "enum",

    "maximum",

    "exclusiveMaximum",

    "minimum",

    "exclusiveMinimum",

    "maxLength",

    "minLength",

    "pattern",

    "maxItems",

    "minItems",

    "uniqueItems",

    "multipleOf",

];

/// Where the 2.0 definition sections move to under `components`, and therefore

/// how `$ref`s into them have to be rewritten.

const REF_MOVES: [(&str, &str); 3] = [

    ("#/definitions/", "#/components/schemas/"),

    ("#/parameters/", "#/components/parameters/"),

    ("#/responses/", "#/components/responses/"),

];

const DEFAULT_MEDIA: &str = "application/json";

const FORM_MEDIA: &str = "application/x-www-form-urlencoded";

const MULTIPART_MEDIA: &str = "multipart/form-data";

/// Is this a Swagger 2.0 document? 3.x documents carry `openapi` instead.

pub fn is_swagger2(doc: &Value) -> bool {

    doc.get("swagger")

        .and_then(Value::as_str)

        .is_some_and(|v| v.starts_with("2."))

}

/// Rewrite a Swagger 2.0 document into an equivalent OpenAPI 3.0 one.

/// Anything the conversion doesn't recognise is carried across untouched, so

/// vendor extensions and unknown fields survive.

pub fn to_openapi3(doc: Value) -> Value {

    let mut doc = doc;

    rewrite_refs(&mut doc);

    let mut root = match doc {

        Value::Object(map) => map,

        other => return other,

    };

    root.remove("swagger");

    let consumes = string_list(root.remove("consumes").as_ref());

    let produces = string_list(root.remove("produces").as_ref());

    let servers = servers_from(&mut root);

    let components = build_components(&mut root, &produces);

    // Parameters are referenced by `$ref` from operations, and whether one is a

    // body parameter decides where it lands — so operation conversion needs to

    // resolve against the components built above.

    let mut refdoc = Map::new();

    refdoc.insert("components".into(), components.clone());

    let refdoc = Value::Object(refdoc);

    let paths = convert_paths(root.remove("paths"), &refdoc, &consumes, &produces);

    let mut out = Map::new();

    out.insert("openapi".into(), Value::from("3.0.0"));

    // Whatever is left (info, security, tags, externalDocs, x-…) keeps its 2.0

    // meaning in 3.0.

    for (key, value) in root {

        out.insert(key, value);

    }

    if !servers.is_empty() {

        out.insert("servers".into(), Value::Array(servers));

    }

    out.insert("paths".into(), paths);

    if components.as_object().is_some_and(|c| !c.is_empty()) {

        out.insert("components".into(), components);

    }

    Value::Object(out)

}

/// Point every local `$ref` at its new home under `components`.

fn rewrite_refs(node: &mut Value) {

    match node {

        Value::Object(map) => {

            if let Some(Value::String(reference)) = map.get_mut("$ref") {

                for (from, to) in REF_MOVES {

                    if let Some(rest) = reference.strip_prefix(from) {

                        *reference = format!("{to}{rest}");

                        break;

                    }

                }

            }

            for (_, child) in map.iter_mut() {

                rewrite_refs(child);

            }

        }

        Value::Array(items) => items.iter_mut().for_each(rewrite_refs),

        _ => {}

    }

}

/// `schemes` × `host` + `basePath` → `servers`. `https` is ordered first when a

/// spec offers both, since that's the better default active server; non-HTTP

/// schemes (`ws`, `wss`) are dropped. A spec with only a `basePath` yields the

/// relative URL it implies, which the user can replace at import time.

fn servers_from(root: &mut Map<String, Value>) -> Vec<Value> {

    let host = take_str(root, "host");

    let base = take_str(root, "basePath");

    let base = base.trim_end_matches('/').to_string();

    if host.is_empty() {

        return if base.is_empty() {

            Vec::new()

        } else {

            vec![server(&base)]

        };

    }

    let mut schemes = string_list(root.remove("schemes").as_ref());

    schemes.retain(|s| s == "http" || s == "https");

    schemes.sort_by_key(|s| usize::from(s != "https"));

    schemes.dedup();

    if schemes.is_empty() {

        schemes.push("https".into());

    }

    schemes

        .iter()

        .map(|scheme| server(&format!("{scheme}://{host}{base}")))

        .collect()

}

fn server(url: &str) -> Value {

    let mut map = Map::new();

    map.insert("url".into(), Value::from(url));

    Value::Object(map)

}

/// Move the 2.0 top-level definition sections under `components`, converting

/// each entry to its 3.0 shape. Shared body/formData parameters are left in 2.0

/// form: they have no 3.0 counterpart, and [`split_params`] lifts them into a

/// `requestBody` wherever they're referenced.

fn build_components(root: &mut Map<String, Value>, produces: &[String]) -> Value {

    let mut components = Map::new();

    if let Some(definitions) = root.remove("definitions") {

        components.insert("schemas".into(), definitions);

    }

    if let Some(Value::Object(params)) = root.remove("parameters") {

        let converted = params

            .into_iter()

            .map(|(name, p)| {

                let value = if is_payload_param(&p) {

                    p

                } else {

                    convert_param(p)

                };

                (name, value)

            })

            .collect();

        components.insert("parameters".into(), Value::Object(converted));

    }

    if let Some(Value::Object(responses)) = root.remove("responses") {

        let converted = responses

            .into_iter()

            .map(|(code, r)| (code, convert_response(r, produces)))

            .collect();

        components.insert("responses".into(), Value::Object(converted));

    }

    if let Some(Value::Object(schemes)) = root.remove("securityDefinitions") {

        let converted = schemes

            .into_iter()

            .map(|(name, s)| (name, convert_security_scheme(s)))

            .collect();

        components.insert("securitySchemes".into(), Value::Object(converted));

    }

    Value::Object(components)

}

/// 2.0 security definitions → 3.0 security schemes. `basic` becomes HTTP basic;

/// oauth2's single `flow` becomes the matching entry in `flows`. `apiKey` is

/// already the 3.0 shape.

fn convert_security_scheme(scheme: Value) -> Value {

    let mut scheme = match scheme {

        Value::Object(map) => map,

        other => return other,

    };

    match scheme.get("type").and_then(Value::as_str) {

        Some("basic") => {

            scheme.insert("type".into(), Value::from("http"));

            scheme.insert("scheme".into(), Value::from("basic"));

        }

        Some("oauth2") => {

            let flow_name = match take_str(&mut scheme, "flow").as_str() {

                "application" => "clientCredentials",

                "accessCode" => "authorizationCode",

                "password" => "password",

                _ => "implicit",

            };

            let mut flow = Map::new();

            for key in ["authorizationUrl", "tokenUrl", "scopes"] {

                if let Some(v) = scheme.remove(key) {

                    flow.insert(key.into(), v);

                }

            }

            flow.entry("scopes")

                .or_insert_with(|| Value::Object(Map::new()));

            let mut flows = Map::new();

            flows.insert(flow_name.into(), Value::Object(flow));

            scheme.insert("flows".into(), Value::Object(flows));

        }

        _ => {}

    }

    Value::Object(scheme)

}

fn convert_paths(

    paths: Option<Value>,

    refdoc: &Value,

    consumes: &[String],

    produces: &[String],

) -> Value {

    let Some(Value::Object(paths)) = paths else {

        return Value::Object(Map::new());

    };

    let mut out = Map::new();

    for (path, item) in paths {

        let mut item = match item {

            Value::Object(map) => map,

            other => {

                out.insert(path, other);

                continue;

            }

        };

        // A path-level body parameter applies to every operation under it.

        let (shared_params, shared_body) =

            split_params(item.remove("parameters"), refdoc, consumes);

        if !shared_params.is_empty() {

            item.insert("parameters".into(), Value::Array(shared_params));

        }

        for method in METHODS {

            if let Some(op) = item.remove(method) {

                let op = convert_operation(op, refdoc, consumes, produces, shared_body.as_ref());

                item.insert(method.into(), op);

            }

        }

        out.insert(path, Value::Object(item));

    }

    Value::Object(out)

}

/// Operation-level `consumes`/`produces` override the document's, and are the

/// media types the lifted `requestBody` and the converted responses are keyed

/// by. Operation-level `schemes` is dropped: 3.0 has no per-operation server.

fn convert_operation(

    op: Value,

    refdoc: &Value,

    consumes: &[String],

    produces: &[String],

    shared_body: Option<&Value>,

) -> Value {

    let mut op = match op {

        Value::Object(map) => map,

        other => return other,

    };

    let consumes = override_list(op.remove("consumes").as_ref(), consumes);

    let produces = override_list(op.remove("produces").as_ref(), produces);

    op.remove("schemes");

    let (params, body) = split_params(op.remove("parameters"), refdoc, &consumes);

    if !params.is_empty() {

        op.insert("parameters".into(), Value::Array(params));

    }

    if let Some(body) = body.or_else(|| shared_body.cloned()) {

        op.insert("requestBody".into(), body);

    }

    if let Some(responses) = op.remove("responses") {

        op.insert("responses".into(), convert_responses(responses, &produces));

    }

    Value::Object(op)

}

/// Split a 2.0 parameter list into the parameters 3.0 still calls parameters

/// and the `requestBody` the rest of them describe. `$ref`s are resolved only

/// far enough to tell which side an entry belongs on: a reference to a

/// query/header/path parameter is left as a reference.

fn split_params(

    params: Option<Value>,

    refdoc: &Value,

    consumes: &[String],

) -> (Vec<Value>, Option<Value>) {

    let Some(Value::Array(params)) = params else {

        return (Vec::new(), None);

    };

    let mut kept = Vec::new();

    let mut form = Vec::new();

    let mut body = None;

    for p in params {

        let resolved = deref(refdoc, &p);

        match resolved.get("in").and_then(Value::as_str) {

            // Last body parameter wins; a spec with two is already invalid.

            Some("body") => body = Some(resolved.clone()),

            Some("formData") => form.push(resolved.clone()),

            _ => kept.push(convert_param(p)),

        }

    }

    let request_body = match body {

        Some(body) => Some(body_request_body(&body, consumes)),

        None if !form.is_empty() => Some(form_request_body(&form, consumes)),

        None => None,

    };

    (kept, request_body)

}

/// A non-body parameter: 2.0 spells its type inline, 3.0 wants a `schema`.

fn convert_param(p: Value) -> Value {

    let mut p = match p {

        Value::Object(map) => map,

        other => return other,

    };

    if p.contains_key("$ref") || p.contains_key("schema") {

        return Value::Object(p);

    }

    // `style`/`explode` are 3.0's answer to collectionFormat; cielago sends

    // array params as a single comma-joined value either way.

    p.remove("collectionFormat");

    if let Some(example) = p.remove("x-example")

        && !p.contains_key("example")

    {

        p.insert("example".into(), example);

    }

    if let Some(schema) = lift_schema_keys(&mut p) {

        p.insert("schema".into(), schema);

    }

    Value::Object(p)

}

/// `in: body` → `requestBody`, keyed by every media type the operation

/// consumes so [`super::import`] can pick the JSON one.

fn body_request_body(param: &Value, consumes: &[String]) -> Value {

    let schema = param

        .get("schema")

        .cloned()

        .unwrap_or(Value::Object(Map::new()));

    let mut content = Map::new();

    for media_type in media_types(consumes) {

        let mut media = Map::new();

        media.insert("schema".into(), schema.clone());

        content.insert(media_type, Value::Object(media));

    }

    let mut body = Map::new();

    if let Some(description) = param.get("description") {

        body.insert("description".into(), description.clone());

    }

    body.insert(

        "required".into(),

        Value::from(param.get("required").and_then(Value::as_bool) == Some(true)),

    );

    body.insert("content".into(), Value::Object(content));

    Value::Object(body)

}

/// `in: formData` parameters are one body between them: they become the

/// properties of a single object schema, the way 3.0 models a form.

fn form_request_body(params: &[Value], consumes: &[String]) -> Value {

    let mut properties = Map::new();

    let mut required = Vec::new();

    let mut has_file = false;

    for p in params {

        let Value::Object(obj) = p else { continue };

        let Some(name) = obj.get("name").and_then(Value::as_str).map(String::from) else {

            continue;

        };

        if obj.get("type").and_then(Value::as_str) == Some("file") {

            has_file = true;

        }

        if obj.get("required").and_then(Value::as_bool) == Some(true) {

            required.push(Value::from(name.clone()));

        }

        let mut obj = obj.clone();

        let mut schema = match lift_schema_keys(&mut obj) {

            Some(Value::Object(schema)) => schema,

            _ => Map::new(),

        };

        if let Some(description) = obj.remove("description") {

            schema.entry("description").or_insert(description);

        }

        properties.insert(name, Value::Object(schema));

    }

    // A file upload has to be multipart; anything else defaults to urlencoded

    // unless the spec named a form media type itself.

    let wanted = if has_file { "multipart/" } else { "form" };

    let media_type = consumes

        .iter()

        .find(|c| c.contains(wanted))

        .cloned()

        .unwrap_or_else(|| {

            if has_file {

                MULTIPART_MEDIA

            } else {

                FORM_MEDIA

            }

            .to_string()

        });

    let mut schema = Map::new();

    schema.insert("type".into(), Value::from("object"));

    if !required.is_empty() {

        schema.insert("required".into(), Value::Array(required.clone()));

    }

    schema.insert("properties".into(), Value::Object(properties));

    let mut media = Map::new();

    media.insert("schema".into(), Value::Object(schema));

    let mut content = Map::new();

    content.insert(media_type, Value::Object(media));

    let mut body = Map::new();

    body.insert("required".into(), Value::from(!required.is_empty()));

    body.insert("content".into(), Value::Object(content));

    Value::Object(body)

}

fn convert_responses(responses: Value, produces: &[String]) -> Value {

    let Value::Object(responses) = responses else {

        return responses;

    };

    let converted = responses

        .into_iter()

        .map(|(code, r)| (code, convert_response(r, produces)))

        .collect();

    Value::Object(converted)

}

/// A 2.0 response carries `schema` (and per-media-type `examples`) directly;

/// 3.0 keys both by media type under `content`.

fn convert_response(response: Value, produces: &[String]) -> Value {

    let mut response = match response {

        Value::Object(map) => map,

        other => return other,

    };

    if let Some(Value::Object(headers)) = response.get_mut("headers") {

        for (_, header) in headers.iter_mut() {

            if let Value::Object(header) = header

                && let Some(schema) = lift_schema_keys(header)

            {

                header.insert("schema".into(), schema);

            }

        }

    }

    if response.contains_key("$ref") || response.contains_key("content") {

        return Value::Object(response);

    }

    let schema = response.remove("schema");

    let examples = response.remove("examples");

    if schema.is_none() && examples.is_none() {

        return Value::Object(response);

    }

    let mut types = media_types(produces);

    if let Some(Value::Object(examples)) = &examples {

        for media_type in examples.keys() {

            if !types.contains(media_type) {

                types.push(media_type.clone());

            }

        }

    }

    let mut content = Map::new();

    for media_type in types {

        let mut media = Map::new();

        if let Some(schema) = &schema {

            media.insert("schema".into(), schema.clone());

        }

        if let Some(example) = examples.as_ref().and_then(|e| e.get(media_type.as_str())) {

            media.insert("example".into(), example.clone());

        }

        if !media.is_empty() {

            content.insert(media_type, Value::Object(media));

        }

    }

    if !content.is_empty() {

        response.insert("content".into(), Value::Object(content));

    }

    Value::Object(response)

}

/// Pull the inline type keywords out of a parameter or header into a schema.

/// 2.0's `type: file` is 3.0's binary string.

fn lift_schema_keys(obj: &mut Map<String, Value>) -> Option<Value> {

    let mut schema = Map::new();

    for key in SCHEMA_KEYS {

        if let Some(v) = obj.remove(key) {

            schema.insert(key.into(), v);

        }

    }

    if schema.is_empty() {

        return None;

    }

    if schema.get("type").and_then(Value::as_str) == Some("file") {

        schema.insert("type".into(), Value::from("string"));

        schema.insert("format".into(), Value::from("binary"));

    }

    Some(Value::Object(schema))

}

fn is_payload_param(p: &Value) -> bool {

    matches!(

        p.get("in").and_then(Value::as_str),

        Some("body") | Some("formData")

    )

}

fn string_list(v: Option<&Value>) -> Vec<String> {

    v.and_then(Value::as_array)

        .map(|a| {

            a.iter()

                .filter_map(Value::as_str)

                .map(String::from)

                .collect()

        })

        .unwrap_or_default()

}

/// An operation-level list wins over the document-level one, but only when it

/// actually lists something.

fn override_list(local: Option<&Value>, inherited: &[String]) -> Vec<String> {

    let local = string_list(local);

    if local.is_empty() {

        inherited.to_vec()

    } else {

        local

    }

}

/// Media types to key a `content` map by, falling back to JSON for a spec that

/// declared none.

fn media_types(list: &[String]) -> Vec<String> {

    if list.is_empty() {

        vec![DEFAULT_MEDIA.to_string()]

    } else {

        list.to_vec()

    }

}

fn take_str(map: &mut Map<String, Value>, key: &str) -> String {

    map.remove(key)

        .and_then(|v| v.as_str().map(str::to_string))

        .unwrap_or_default()

}

#[cfg(test)]

mod tests {

    use super::*;

    use serde_json::json;

    fn convert(doc: Value) -> Value {

        assert!(is_swagger2(&doc));

        to_openapi3(doc)

    }

    #[test]

    fn detects_the_dialect() {

        assert!(is_swagger2(&json!({"swagger": "2.0"})));

        assert!(!is_swagger2(&json!({"openapi": "3.0.3"})));

        assert!(!is_swagger2(&json!({})));

    }

    #[test]

    fn host_base_path_and_schemes_become_servers() {

        let out = convert(json!({

            "swagger": "2.0",

            "host": "api.example.com",

            "basePath": "/v1/",

            "schemes": ["http", "https", "wss"]

        }));

        // https first, the trailing slash trimmed, non-HTTP schemes dropped.

        assert_eq!(

            out["servers"],

            json!([

                {"url": "https://api.example.com/v1"},

                {"url": "http://api.example.com/v1"}

            ])

        );

    }

    #[test]

    fn missing_scheme_defaults_to_https_and_missing_host_keeps_base_path() {

        let out = convert(json!({"swagger": "2.0", "host": "api.example.com"}));

        assert_eq!(out["servers"], json!([{"url": "https://api.example.com"}]));

        let out = convert(json!({"swagger": "2.0", "basePath": "/v1"}));

        assert_eq!(out["servers"], json!([{"url": "/v1"}]));

        let out = convert(json!({"swagger": "2.0"}));

        assert!(out.get("servers").is_none());

    }

    #[test]

    fn definitions_move_and_refs_follow_them() {

        let out = convert(json!({

            "swagger": "2.0",

            "definitions": {"Pet": {"type": "object", "properties": {

                "friend": {"$ref": "#/definitions/Pet"}

            }}},

            "paths": {"/pets": {"post": {

                "parameters": [{"name": "body", "in": "body", "schema": {"$ref": "#/definitions/Pet"}}],

                "responses": {}

            }}}

        }));

        assert_eq!(out["components"]["schemas"]["Pet"]["type"], "object");

        assert_eq!(

            out["components"]["schemas"]["Pet"]["properties"]["friend"]["$ref"],

            "#/components/schemas/Pet"

        );

        assert_eq!(

            out["paths"]["/pets"]["post"]["requestBody"]["content"]["application/json"]["schema"]["$ref"],

            "#/components/schemas/Pet"

        );

    }

    #[test]

    fn body_parameter_becomes_a_request_body() {

        let out = convert(json!({

            "swagger": "2.0",

            "consumes": ["application/xml"],

            "paths": {"/pets": {"post": {

                "parameters": [

                    {"name": "pet", "in": "body", "required": true,

                     "description": "the pet", "schema": {"type": "object"}},

                    {"name": "trace", "in": "header", "type": "string"}

                ],

                "responses": {}

            }}}

        }));

        let op = &out["paths"]["/pets"]["post"];

        assert_eq!(op["requestBody"]["required"], true);

        assert_eq!(op["requestBody"]["description"], "the pet");

        assert_eq!(

            op["requestBody"]["content"]["application/xml"]["schema"]["type"],

            "object"

        );

        // The body parameter left the parameter list; the header stayed.

        assert_eq!(op["parameters"].as_array().unwrap().len(), 1);

        assert_eq!(op["parameters"][0]["name"], "trace");

    }

    #[test]

    fn form_data_parameters_become_one_object_schema() {

        let out = convert(json!({

            "swagger": "2.0",

            "paths": {"/upload": {"post": {

                "parameters": [

                    {"name": "caption", "in": "formData", "required": true,

                     "type": "string", "description": "what it shows"},

                    {"name": "photo", "in": "formData", "type": "file"}

                ],

                "responses": {}

            }}}

        }));

        let body = &out["paths"]["/upload"]["post"]["requestBody"];

        // A file forces multipart even though the spec listed no `consumes`.

        let schema = &body["content"]["multipart/form-data"]["schema"];

        assert_eq!(schema["type"], "object");

        assert_eq!(schema["required"], json!(["caption"]));

        assert_eq!(schema["properties"]["caption"]["type"], "string");

        assert_eq!(

            schema["properties"]["caption"]["description"],

            "what it shows"

        );

        // 2.0's `file` type is 3.0's binary string.

        assert_eq!(schema["properties"]["photo"]["type"], "string");

        assert_eq!(schema["properties"]["photo"]["format"], "binary");

    }

    #[test]

    fn form_without_a_file_defaults_to_urlencoded() {

        let out = convert(json!({

            "swagger": "2.0",

            "paths": {"/login": {"post": {

                "parameters": [{"name": "user", "in": "formData", "type": "string"}],

                "responses": {}

            }}}

        }));

        let content = &out["paths"]["/login"]["post"]["requestBody"]["content"];

        assert!(content.get("application/x-www-form-urlencoded").is_some());

    }

    #[test]

    fn inline_parameter_types_move_under_schema() {

        let out = convert(json!({

            "swagger": "2.0",

            "parameters": {"PetId": {

                "name": "petId", "in": "path", "required": true,

                "type": "integer", "format": "int64", "x-example": 123

            }},

            "paths": {"/pets": {"get": {

                "parameters": [{

                    "name": "tags", "in": "query", "type": "array",

                    "collectionFormat": "csv",

                    "items": {"type": "string", "enum": ["cat", "dog"]}

                }],

                "responses": {}

            }}}

        }));

        let shared = &out["components"]["parameters"]["PetId"];

        assert_eq!(

            shared["schema"],

            json!({"type": "integer", "format": "int64"})

        );

        assert_eq!(shared["in"], "path");

        // `x-example` is 2.0's only way to give a non-body parameter an example.

        assert_eq!(shared["example"], 123);

        let p = &out["paths"]["/pets"]["get"]["parameters"][0];

        assert_eq!(p["schema"]["type"], "array");

        assert_eq!(p["schema"]["items"]["enum"], json!(["cat", "dog"]));

        assert!(p.get("collectionFormat").is_none());

        assert!(p.get("type").is_none());

    }

    #[test]

    fn path_level_body_applies_to_each_operation() {

        let out = convert(json!({

            "swagger": "2.0",

            "paths": {"/pets": {

                "parameters": [

                    {"name": "pet", "in": "body", "schema": {"type": "object"}},

                    {"name": "petId", "in": "path", "required": true, "type": "string"}

                ],

                "put": {"responses": {}},

                "post": {

                    "parameters": [{"name": "own", "in": "body", "schema": {"type": "string"}}],

                    "responses": {}

                }

            }}

        }));

        let item = &out["paths"]["/pets"];

        // The path-level parameter list keeps only what 3.0 calls a parameter.

        assert_eq!(item["parameters"].as_array().unwrap().len(), 1);

        assert_eq!(item["parameters"][0]["schema"]["type"], "string");

        assert_eq!(

            item["put"]["requestBody"]["content"]["application/json"]["schema"]["type"],

            "object"

        );

        // An operation's own body wins over the inherited one.

        assert_eq!(

            item["post"]["requestBody"]["content"]["application/json"]["schema"]["type"],

            "string"

        );

    }

    #[test]

    fn security_definitions_become_security_schemes() {

        let out = convert(json!({

            "swagger": "2.0",

            "securityDefinitions": {

                "oauth": {

                    "type": "oauth2",

                    "flow": "application",

                    "tokenUrl": "https://auth.example.com/token",

                    "scopes": {"read": "Read"}

                },

                "code": {

                    "type": "oauth2",

                    "flow": "accessCode",

                    "authorizationUrl": "https://auth.example.com/authorize",

                    "tokenUrl": "https://auth.example.com/token"

                },

                "basic": {"type": "basic"},

                "key": {"type": "apiKey", "name": "X-Api-Key", "in": "header"}

            }

        }));

        let schemes = &out["components"]["securitySchemes"];

        assert_eq!(

            schemes["oauth"]["flows"]["clientCredentials"]["tokenUrl"],

            "https://auth.example.com/token"

        );

        assert_eq!(

            schemes["oauth"]["flows"]["clientCredentials"]["scopes"]["read"],

            "Read"

        );

        assert!(schemes["oauth"].get("flow").is_none());

        assert_eq!(

            schemes["code"]["flows"]["authorizationCode"]["authorizationUrl"],

            "https://auth.example.com/authorize"

        );

        // A flow with no declared scopes still gets the map 3.0 requires.

        assert_eq!(

            schemes["code"]["flows"]["authorizationCode"]["scopes"],

            json!({})

        );

        assert_eq!(schemes["basic"], json!({"type": "http", "scheme": "basic"}));

        assert_eq!(

            schemes["key"],

            json!({"type": "apiKey", "name": "X-Api-Key", "in": "header"})

        );

    }

    #[test]

    fn response_schemas_and_examples_move_under_content() {

        let out = convert(json!({

            "swagger": "2.0",

            "produces": ["application/json"],

            "paths": {"/pets": {"get": {

                "responses": {

                    "200": {

                        "description": "ok",

                        "schema": {"type": "array", "items": {"type": "string"}},

                        "examples": {"application/json": ["fido"]}

                    },

                    "204": {"description": "empty"}

                }

            }}}

        }));

        let responses = &out["paths"]["/pets"]["get"]["responses"];

        let media = &responses["200"]["content"]["application/json"];

        assert_eq!(media["schema"]["type"], "array");

        assert_eq!(media["example"], json!(["fido"]));

        assert_eq!(responses["200"]["description"], "ok");

        // Nothing to describe means no `content` at all.

        assert!(responses["204"].get("content").is_none());

    }

    #[test]

    fn operation_media_types_override_the_document() {

        let out = convert(json!({

            "swagger": "2.0",

            "consumes": ["application/json"],

            "produces": ["application/json"],

            "paths": {"/pets": {"post": {

                "consumes": ["text/plain"],

                "produces": ["text/plain"],

                "parameters": [{"name": "b", "in": "body", "schema": {"type": "string"}}],

                "responses": {"200": {"description": "ok", "schema": {"type": "string"}}}

            }}}

        }));

        let op = &out["paths"]["/pets"]["post"];

        assert!(op["requestBody"]["content"].get("text/plain").is_some());

        assert!(

            op["requestBody"]["content"]

                .get("application/json")

                .is_none()

        );

        assert!(

            op["responses"]["200"]["content"]

                .get("text/plain")

                .is_some()

        );

        assert!(op.get("consumes").is_none());

    }

    #[test]

    fn response_headers_get_schemas() {

        let out = convert(json!({

            "swagger": "2.0",

            "paths": {"/pets": {"get": {"responses": {"200": {

                "description": "ok",

                "headers": {"X-Rate-Limit": {"type": "integer", "description": "calls left"}}

            }}}}}

        }));

        let header = &out["paths"]["/pets"]["get"]["responses"]["200"]["headers"]["X-Rate-Limit"];

        assert_eq!(header["schema"], json!({"type": "integer"}));

        assert_eq!(header["description"], "calls left");

    }

    #[test]

    fn unrecognised_fields_are_carried_across() {

        let out = convert(json!({

            "swagger": "2.0",

            "info": {"title": "t", "version": "1"},

            "tags": [{"name": "pets"}],

            "security": [{"key": []}],

            "x-logo": {"url": "https://example.com/logo.png"}

        }));

        assert_eq!(out["openapi"], "3.0.0");

        assert!(out.get("swagger").is_none());

        assert_eq!(out["info"]["title"], "t");

        assert_eq!(out["tags"][0]["name"], "pets");

        assert_eq!(out["security"], json!([{"key": []}]));

        assert_eq!(out["x-logo"]["url"], "https://example.com/logo.png");

    }

}