tmdb-api-tests.json

{
  "info": {
    "_postman_id": "13c47a62-68b3-49ca-9fb0-49d12c833d36",
    "name": "TMDB Portfolio",
    "description": "Postman test collection for The Movie Database (TMDB) API. Tests movie and TV popular list and detail page endpoints covering schema validation, pagination metadata, date format, ISO format validation, data integrity checks, chained requests using dynamically captured IDs, and response time. See README for full details.\n\n  \n[https://github.com/Alianin/api-testing-portfolio](https://github.com/Alianin/api-testing-portfolio)",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
    "_exporter_id": "51474602",
    "_collection_link": "https://go.postman.co/collection/51474602-13c47a62-68b3-49ca-9fb0-49d12c833d36?source=collection_link"
  },
  "item": [
    {
      "name": "Authentication",
      "item": [
        {
          "name": "Valid auth",
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "// -----------------------------\r",
                  "// GET FOLDER VARIABLES\r",
                  "// -----------------------------\r",
                  "const jsonData = JSON.parse(pm.variables.get(\"jsonData\"));\r",
                  "const schemaFailures = JSON.parse(pm.variables.get(\"schemaFailures\"));\r",
                  "\r",
                  "// -----------------------------\r",
                  "// TESTS\r",
                  "// -----------------------------\r",
                  "pm.test(\"Status code is 200\", () => {\r",
                  "    pm.response.to.have.status(200);\r",
                  "});\r",
                  "pm.test(\"Response is JSON\", () => {\r",
                  "    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");\r",
                  "});\r",
                  "pm.test(\"All items match expected schema\", () => {\r",
                  "    const failureSummary = schemaFailures.map(f =>\r",
                  "    f.errors.map(e => e.message).join(\",\")\r",
                  "    ).join(\" | \");\r",
                  "    pm.expect(schemaFailures.length, failureSummary).to.eql(0);\r",
                  "});\r",
                  "pm.test(\"Success is true\", () => {\r",
                  "    pm.expect(jsonData.success).to.eql(true);\r",
                  "});\r",
                  "pm.test(\"Response time is acceptable\", () => {\r",
                  "    pm.expect(pm.response.responseTime).to.be.below(500);\r",
                  "})"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/authentication",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "authentication"
              ]
            },
            "description": "Validates that a valid access token is accepted and returns a success response.\n\nAPI docs: [https://developer.themoviedb.org/reference/authentication-validate-key](https://developer.themoviedb.org/reference/authentication-validate-key)"
          },
          "response": []
        },
        {
          "name": "Invalid auth",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "pm.request.headers.upsert({\r",
                  "    key: \"Authorization\",\r",
                  "    value: \"Bearer invalid_token\"\r",
                  "});"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            },
            {
              "listen": "test",
              "script": {
                "exec": [
                  "// -----------------------------\r",
                  "// GET FOLDER VARIABLES\r",
                  "// -----------------------------\r",
                  "const jsonData = JSON.parse(pm.variables.get(\"jsonData\"));\r",
                  "const schemaFailures = JSON.parse(pm.variables.get(\"schemaFailures\"));\r",
                  "\r",
                  "// -----------------------------\r",
                  "// TESTS\r",
                  "// -----------------------------\r",
                  "pm.test(\"Status code is 401 Unauthorized\", () => {\r",
                  "    pm.response.to.have.status(401);\r",
                  "});\r",
                  "pm.test(\"Response is JSON\", () => {\r",
                  "    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");\r",
                  "});\r",
                  "pm.test(\"All items match expected schema\", () => {\r",
                  "    const failureSummary = schemaFailures.map(f =>\r",
                  "    f.errors.map(e => e.message).join(\",\")\r",
                  "    ).join(\" | \");\r",
                  "    pm.expect(schemaFailures.length, failureSummary).to.eql(0);\r",
                  "});\r",
                  "pm.test(\"Success is false\", () => {\r",
                  "    pm.expect(jsonData.success).to.eql(false);\r",
                  "});\r",
                  "pm.test(\"Response time is acceptable\", () => {\r",
                  "    pm.expect(pm.response.responseTime).to.be.below(500);\r",
                  "})"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "auth": {
              "type": "noauth"
            },
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/authentication",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "authentication"
              ]
            },
            "description": "Validates that an invalid access token is rejected and returns an unauthorized response.\n\nAPI docs: [https://developer.themoviedb.org/reference/authentication-validate-key](https://developer.themoviedb.org/reference/authentication-validate-key)"
          },
          "response": []
        }
      ],
      "description": "Tests the authentication endpoint covering schema validation, success state, and response time for both valid and invalid credentials.",
      "event": [
        {
          "listen": "prerequest",
          "script": {
            "type": "text/javascript",
            "packages": {},
            "requests": {},
            "exec": [
              ""
            ]
          }
        },
        {
          "listen": "test",
          "script": {
            "type": "text/javascript",
            "packages": {},
            "requests": {},
            "exec": [
              "const Ajv = require('ajv');\r",
              "const ajv = new Ajv({ allErrors: true });\r",
              "\r",
              "// -----------------------------\r",
              "// AUTH SCHEMA DEFINITION\r",
              "// -----------------------------\r",
              "const authSchema = {\r",
              "    type: \"object\",\r",
              "    required: [\"success\"],\r",
              "    properties: {\r",
              "        success: {type: \"boolean\"}\r",
              "    }\r",
              "};\r",
              "\r",
              "// -----------------------------\r",
              "// PARSE RESPONSE\r",
              "// -----------------------------\r",
              "const jsonData = pm.response.json();\r",
              "\r",
              "// -----------------------------\r",
              "// VALIDATION\r",
              "// -----------------------------\r",
              "const validateResult = ajv.compile(authSchema);\r",
              "const validSchema = validateResult(jsonData);\r",
              "\r",
              "let schemaFailures = [];\r",
              "\r",
              "if (!validSchema) {\r",
              "    schemaFailures.push({\r",
              "        errors: validateResult.errors\r",
              "    });\r",
              "};\r",
              "\r",
              "// -----------------------------\r",
              "// STORE DATA FOR REQUEST SCRIPTS\r",
              "// -----------------------------\r",
              "pm.variables.set(\"jsonData\", JSON.stringify(jsonData));\r",
              "pm.variables.set(\"schemaFailures\", JSON.stringify(schemaFailures));\r",
              "\r",
              "// -----------------------------\r",
              "// DEBUG LOGGING\r",
              "// -----------------------------\r",
              "console.log(`Auth test summary`);\r",
              "console.log(\"Schema failures:\", schemaFailures);"
            ]
          }
        }
      ]
    },
    {
      "name": "Popular lists",
      "item": [
        {
          "name": "Popular movie list",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "pm.variables.set(\"listName\", \"movie\");"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/movie/popular",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "movie",
                "popular"
              ]
            },
            "description": "Returns a paginated list of popular movies. Validates schema, pagination metadata, date formats, and duplicate IDs. Captures the first movie ID for use in the Movie detail request.\n\nAPI docs: [https://developer.themoviedb.org/reference/movie-popular-list](https://developer.themoviedb.org/reference/movie-popular-list)"
          },
          "response": []
        },
        {
          "name": "Popular TV show list",
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  ""
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            },
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "pm.variables.set(\"listName\", \"tv\");"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/tv/popular",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "tv",
                "popular"
              ]
            },
            "description": "Returns a paginated list of popular TV shows. Validates schema, pagination metadata, date formats, and duplicate IDs. Captures the first TV show ID for use in the TV detail request.\n\nAPI docs: [https://developer.themoviedb.org/reference/tv-series-popular-list](https://developer.themoviedb.org/reference/tv-series-popular-list)"
          },
          "response": []
        }
      ],
      "description": "Tests the movie and TV popular list endpoints covering schema validation, pagination metadata, date format, duplicate detection, response time, and ID capture for detail request chaining.",
      "event": [
        {
          "listen": "prerequest",
          "script": {
            "type": "text/javascript",
            "packages": {},
            "requests": {},
            "exec": [
              ""
            ]
          }
        },
        {
          "listen": "test",
          "script": {
            "type": "text/javascript",
            "packages": {},
            "requests": {},
            "exec": [
              "const Ajv = require('ajv');\r",
              "const ajv = new Ajv({ allErrors: true });\r",
              "\r",
              "// -----------------------------\r",
              "// LIST SCHEMA DEFINITIONS\r",
              "// -----------------------------\r",
              "const listSchemas = {\r",
              "\tmovie: {\r",
              "\t\ttype: \"object\",\r",
              "\t\trequired: [\"adult\", \"id\", \"original_language\", \"original_title\", \"overview\", \"popularity\", \"release_date\", \"title\", \"video\", \"vote_average\", \"vote_count\"],\r",
              "\t\tproperties: {\r",
              "            adult: {type: \"boolean\"},\r",
              "            backdrop_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            genre_ids: {type: \"array\", items: {type: \"integer\"}},\r",
              "\t\t\tid: {type: \"integer\", minimum: 1},\r",
              "            original_language: {type: \"string\"},\r",
              "            original_title: {type: \"string\", minLength: 1},\r",
              "            overview: {type: \"string\"},\r",
              "            popularity: {type: \"number\", minimum: 0},\r",
              "            poster_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            release_date: {type: \"string\"},\r",
              "            title: {type: \"string\", minLength: 1},\r",
              "            video: {type: \"boolean\"},\r",
              "            vote_average: {type: \"number\", minimum: 0, maximum: 10},\r",
              "            vote_count: {type: \"integer\", minimum: 0}\r",
              "\t\t}\r",
              "\t},\r",
              "    tv: {\r",
              "\t\ttype: \"object\",\r",
              "\t\trequired: [\"adult\", \"id\", \"origin_country\", \"original_language\", \"original_name\", \"overview\", \"popularity\", \"first_air_date\", \"name\", \"vote_average\", \"vote_count\"],\r",
              "\t\tproperties: {\r",
              "            adult: {type: \"boolean\"},\r",
              "            backdrop_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            genre_ids: {type: \"array\", items: {type: \"integer\"}},\r",
              "\t\t\tid: {type: \"integer\", minimum: 1},\r",
              "            origin_country: {type: \"array\", items: {type: \"string\"}, minItems: 1},\r",
              "            original_language: {type: \"string\"},\r",
              "            original_name: {type: \"string\", minLength: 1},\r",
              "            overview: {type: \"string\"},\r",
              "            popularity: {type: \"number\", minimum: 0},\r",
              "            poster_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            first_air_date: {type: \"string\"},\r",
              "            name: {type: \"string\", minLength: 1},\r",
              "            vote_average: {type: \"number\", minimum: 0, maximum: 10},\r",
              "            vote_count: {type: \"integer\", minimum: 0}\r",
              "\t\t}\r",
              "\t}\r",
              "}\r",
              "\r",
              "// -----------------------------\r",
              "// DETERMINE LIST TYPE\r",
              "// -----------------------------\r",
              "const listName = pm.variables.get(\"listName\");\r",
              "\r",
              "if (!listSchemas[listName]) {\r",
              "    throw new Error(`No schema defined for list \"${listName}\"`);\r",
              "}\r",
              "\r",
              "const listSchema = listSchemas[listName];\r",
              "const validateResult = ajv.compile(listSchema);\r",
              "\r",
              "// -----------------------------\r",
              "// PARSE RESPONSE\r",
              "// -----------------------------\r",
              "const jsonData = pm.response.json();\r",
              "const dataResults = jsonData.results || [];\r",
              "\r",
              "// -----------------------------\r",
              "// TRACKING & REGEX VARIABLES\r",
              "// -----------------------------\r",
              "let totalResults = dataResults.length;\r",
              "let schemaFailures = [];\r",
              "let dateFailures = [];\r",
              "let duplicateIds = [];\r",
              "let idsSeen = new Set();\r",
              "\r",
              "const iso8601Regex = /^\\d{4}-\\d{2}-\\d{2}$/;\r",
              "\r",
              "// -----------------------------\r",
              "// VALIDATION LOOP\r",
              "// -----------------------------\r",
              "dataResults.forEach(result => {\r",
              "\r",
              "    // Schema checks\r",
              "    const validSchema = validateResult(result);\r",
              "    if (!validSchema) {\r",
              "        schemaFailures.push({\r",
              "            id: result.id,\r",
              "            errors: validateResult.errors\r",
              "        });\r",
              "    }\r",
              "\r",
              "    // Date validation\r",
              "    [\"release_date\", \"first_air_date\"].forEach(field => {\r",
              "        if (result[field] && !iso8601Regex.test(result[field])) {\r",
              "            dateFailures.push(`${result.id} - ${field}: ${result[field]}`);\r",
              "        }\r",
              "    });\r",
              "\r",
              "    // Duplicate detection\r",
              "    if (idsSeen.has(result.id)) {\r",
              "        duplicateIds.push(result.id);\r",
              "    }\r",
              "\r",
              "    idsSeen.add(result.id);\r",
              "});\r",
              "\r",
              "// Store IDs to be used in chained request tests\r",
              "if (listName === \"movie\") {\r",
              "    pm.collectionVariables.set(\"movieId\", dataResults[0].id);\r",
              "} else if (listName === \"tv\") {\r",
              "    pm.collectionVariables.set(\"tvId\", dataResults[0].id);\r",
              "}\r",
              "\r",
              "// -----------------------------\r",
              "// TESTS\r",
              "// -----------------------------\r",
              "pm.test(\"Status code is 200\", () => {\r",
              "    pm.response.to.have.status(200);\r",
              "});\r",
              "pm.test(\"Response is JSON\", () => {\r",
              "    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");\r",
              "});\r",
              "pm.test(\"Page defaults to 1\", () => {\r",
              "    pm.expect(jsonData.page).to.eql(1);\r",
              "});\r",
              "pm.test(\"Total pages is greater than zero\", () => {\r",
              "    pm.expect(jsonData.total_pages).to.be.above(0);\r",
              "});\r",
              "pm.test(\"Response contains results\", () => {\r",
              "    pm.expect(jsonData.results.length).to.be.above(0);\r",
              "});\r",
              "pm.test(\"Total results is greater than zero\", () => {\r",
              "    pm.expect(jsonData.total_results).to.be.above(0);\r",
              "});\r",
              "pm.test(\"Total results is greater than or equal to results\", () => {\r",
              "    pm.expect(jsonData.total_results).to.be.gte(jsonData.results.length);\r",
              "});\r",
              "pm.test(\"No duplicate IDs in list results\", () => {\r",
              "    pm.expect(duplicateIds.length).to.eql(0);\r",
              "});\r",
              "pm.test(\"All objects match expected schema\", () => {\r",
              "    const failureSummary = schemaFailures.map(f =>\r",
              "    `ID ${f.id}: ${f.errors.map(e => e.message).join(\",\")}`\r",
              "    ).join(\" | \");\r",
              "    pm.expect(schemaFailures.length, failureSummary).to.eql(0);\r",
              "});\r",
              "pm.test(\"All date fields are valid ISO 8601 format\", () => {\r",
              "    pm.expect(dateFailures.length).to.eql(0);\r",
              "});\r",
              "pm.test(\"Response time is acceptable\", () => {\r",
              "    pm.expect(pm.response.responseTime).to.be.below(500);\r",
              "});\r",
              "\r",
              "// -----------------------------\r",
              "// DEBUG LOGGING\r",
              "// -----------------------------\r",
              "console.log(`List test summary for ${listName}`);\r",
              "console.log(\"Results:\", totalResults);\r",
              "console.log(\"Schema failures:\", schemaFailures);\r",
              "console.log(\"Date failures\", dateFailures);\r",
              "console.log(\"Duplicate IDs:\", duplicateIds);"
            ]
          }
        }
      ]
    },
    {
      "name": "Page detail",
      "item": [
        {
          "name": "Movie detail",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const movieId = pm.collectionVariables.get(\"movieId\");\r",
                  "if (!movieId) { // Ensure that the movieId exists since the API call requires an ID\r",
                  "    throw new Error(\"movieId not set — run the Popular Lists requests first\");\r",
                  "}\r",
                  "pm.variables.set(\"detailName\", \"movie\");"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/movie/{{movieId}}",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "movie",
                "{{movieId}}"
              ]
            },
            "description": "Returns full details for a movie. ID is dynamically captured from the Movie popular list request. Validates schema, date formats, ISO country and language codes, and response ID consistency.\n\nAPI docs: [https://developer.themoviedb.org/reference/movie-details](https://developer.themoviedb.org/reference/movie-details)"
          },
          "response": []
        },
        {
          "name": "TV detail",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "const tvId = pm.collectionVariables.get(\"tvId\");\r",
                  "if (!tvId) { // Ensure that the tvId exists since the API call requires an ID\r",
                  "    throw new Error(\"tvId not set — run the Popular lists requests first\");\r",
                  "}\r",
                  "pm.variables.set(\"detailName\", \"tv\");"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/tv/{{tvId}}",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "tv",
                "{{tvId}}"
              ]
            },
            "description": "Returns full details for a TV show. ID is dynamically captured from the TV popular list request. Validates schema, date formats, ISO codes, season count consistency, episode/season ratio, and that ended shows have no next episode scheduled.\n\nAPI docs: [https://developer.themoviedb.org/reference/tv-series-details](https://developer.themoviedb.org/reference/tv-series-details)"
          },
          "response": []
        }
      ],
      "description": "Tests the movie and TV detail page endpoints covering schema validation, date format, ISO format validation on country and language codes, data integrity checks (season count consistency, episode/season ratio, ended shows without next episodes), response ID verification, and response time. Chained from Popular lists using dynamically captured IDs.",
      "event": [
        {
          "listen": "prerequest",
          "script": {
            "type": "text/javascript",
            "packages": {},
            "requests": {},
            "exec": [
              ""
            ]
          }
        },
        {
          "listen": "test",
          "script": {
            "type": "text/javascript",
            "packages": {},
            "requests": {},
            "exec": [
              "const Ajv = require('ajv');\r",
              "const ajv = new Ajv({ allErrors: true });\r",
              "\r",
              "// -----------------------------\r",
              "// DETAIL SCHEMA DEFINITIONS\r",
              "// -----------------------------\r",
              "const detailSchemas = {\r",
              "\tmovie: {\r",
              "\t\ttype: \"object\",\r",
              "\t\trequired: [\"adult\", \"id\", \"original_language\", \"original_title\", \"overview\", \"popularity\", \"release_date\", \"title\", \"video\", \"vote_average\", \"vote_count\"],\r",
              "\t\tproperties: {\r",
              "            adult: {type: \"boolean\"},\r",
              "            backdrop_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            belongs_to_collection: {\r",
              "                oneOf: [\r",
              "                    {type: \"null\"}, // Not documented to allow null, but an observed response\r",
              "                    {\r",
              "                        type: \"object\",\r",
              "                        required: [\"id\", \"name\"],\r",
              "                        properties: {\r",
              "                            id: {type: \"integer\", minimum: 1},\r",
              "                            name: {type: \"string\"},\r",
              "                            poster_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                            backdrop_path: {type: [\"string\", \"null\"]} // Not documented to allow null, but an observed response\r",
              "                        }\r",
              "                    }\r",
              "                ]\r",
              "            },\r",
              "            budget: {type: \"integer\", minimum: 0},\r",
              "            genres: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"id\", \"name\"],\r",
              "                    properties: {\r",
              "                        id: {type: \"integer\", minimum: 1},\r",
              "                        name: {type: \"string\", minLength: 1}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            homepage: {type: \"string\"},\r",
              "\t\t\tid: {type: \"integer\", minimum: 1},\r",
              "            imdb_id: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            original_language: {type: \"string\"},\r",
              "            original_title: {type: \"string\", minLength: 1},\r",
              "            overview: {type: \"string\"},\r",
              "            popularity: {type: \"number\", minimum: 0},\r",
              "            poster_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            production_companies: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"id\", \"name\", \"origin_country\"],\r",
              "                    properties: {\r",
              "                        id: {type: \"integer\", minimum: 1},\r",
              "                        logo_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                        name: {type: \"string\", minLength: 1},\r",
              "                        origin_country: {type: \"string\"}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            production_countries: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"iso_3166_1\", \"name\"],\r",
              "                    properties: {\r",
              "                        iso_3166_1: {type: \"string\", pattern: \"^[A-Z]{2}$\"},\r",
              "                        name: {type: \"string\", minLength: 1}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            release_date: {type: \"string\"},\r",
              "            revenue: {type: \"integer\", minimum: 0},\r",
              "            runtime: {type: \"integer\", minimum: 1},\r",
              "            spoken_languages: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"english_name\", \"iso_639_1\", \"name\"],\r",
              "                    properties: {\r",
              "                        english_name: {type: \"string\", minLength: 1},\r",
              "                        iso_639_1: {type: \"string\", pattern: \"^[a-z]{2}$\"},\r",
              "                        name: {type: \"string\", minLength: 1}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            status: {type: \"string\", minLength: 1},\r",
              "            tagline: {type: \"string\"},\r",
              "            title: {type: \"string\", minLength: 1},\r",
              "            video: {type: \"boolean\"},\r",
              "            vote_average: {type: \"number\", minimum: 0, maximum: 10},\r",
              "            vote_count: {type: \"integer\", minimum: 0}\r",
              "\t\t}\r",
              "\t},\r",
              "    tv: {\r",
              "        type: \"object\",\r",
              "        required: [\"adult\", \"first_air_date\", \"id\", \"in_production\", \"name\", \"number_of_episodes\", \"number_of_seasons\", \"original_language\", \"original_name\", \"overview\", \"popularity\", \"status\", \"vote_average\", \"vote_count\"],\r",
              "        properties: {\r",
              "            adult: {type: \"boolean\"},\r",
              "            backdrop_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            created_by: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"id\", \"name\", \"gender\"],\r",
              "                    properties: {\r",
              "                        id: {type: \"integer\", minimum: 1},\r",
              "                        credit_id: {type: \"string\"},\r",
              "                        name: {type: \"string\", minLength: 1},\r",
              "                        original_name: {type: \"string\"}, // Undocumented property\r",
              "                        gender: {type: \"integer\", minimum: 0},\r",
              "                        profile_path: {type: [\"string\", \"null\"]} // Not documented to allow null, but an observed response\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            episode_run_time: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"integer\"\r",
              "                }\r",
              "            },\r",
              "            first_air_date: {type: \"string\"},\r",
              "            genres: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"id\", \"name\"],\r",
              "                    properties: {\r",
              "                        id: {type: \"integer\", minimum: 1},\r",
              "                        name: {type: \"string\", minLength: 1}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            homepage: {type: \"string\"},\r",
              "            id: {type: \"integer\", minimum: 1},\r",
              "            in_production: {type: \"boolean\"},\r",
              "            languages: {\r",
              "                type: \"array\",\r",
              "                items: {type: \"string\"}\r",
              "            },\r",
              "            last_air_date: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            last_episode_to_air: {\r",
              "                oneOf: [\r",
              "                    {type: \"null\"}, // Not documented to allow null, but an observed response\r",
              "                    {\r",
              "                        type: \"object\",\r",
              "                        required: [\"id\", \"vote_average\", \"vote_count\", \"episode_number\", \"runtime\", \"season_number\", \"show_id\"],\r",
              "                        properties: {\r",
              "                            id: {type: \"integer\", minimum: 1},\r",
              "                            name: {type: \"string\", minLength: 1},\r",
              "                            overview: {type: \"string\"},\r",
              "                            vote_average: {type: \"number\", minimum: 0, maximum: 10},\r",
              "                            vote_count: {type: \"integer\", minimum: 0},\r",
              "                            air_date: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                            episode_number: {type: \"integer\", minimum: 0},\r",
              "                            episode_type: {type: \"string\"}, // Undocumented property\r",
              "                            production_code: {type: \"string\"},\r",
              "                            runtime: {type: [\"integer\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                            season_number: {type: \"integer\", minimum: 0},\r",
              "                            show_id: {type: \"integer\", minimum: 1},\r",
              "                            still_path: {type: [\"string\", \"null\"]} // Not documented to allow null, but an observed response\r",
              "                        }\r",
              "                    }\r",
              "                ]\r",
              "            },\r",
              "            name: {type: \"string\", minLength: 1},\r",
              "            next_episode_to_air: {\r",
              "                oneOf: [ // Documented as a string, but observed to return null or an object\r",
              "                    {type: \"null\"}, // Not documented to allow null, but an observed response\r",
              "                    {\r",
              "                        type: \"object\",\r",
              "                        required: [\"id\", \"vote_average\", \"vote_count\", \"episode_number\", \"runtime\", \"season_number\", \"show_id\"],\r",
              "                        properties: {\r",
              "                            id: {type: \"integer\", minimum: 1},\r",
              "                            name: {type: \"string\", minLength: 1},\r",
              "                            overview: {type: \"string\"},\r",
              "                            vote_average: {type: \"number\", minimum: 0, maximum: 10},\r",
              "                            vote_count: {type: \"integer\", minimum: 0},\r",
              "                            air_date: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                            episode_number: {type: \"integer\", minimum: 0},\r",
              "                            episode_type: {type: \"string\"}, // Undocumented property\r",
              "                            production_code: {type: \"string\"},\r",
              "                            runtime: {type: [\"integer\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                            season_number: {type: \"integer\", minimum: 0},\r",
              "                            show_id: {type: \"integer\", minimum: 1},\r",
              "                            still_path: {type: [\"string\", \"null\"]} // Not documented to allow null, but an observed response\r",
              "                        }\r",
              "                    }\r",
              "                ]\r",
              "            },\r",
              "            networks: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"id\", \"name\"],\r",
              "                    properties: {\r",
              "                        id: {type: \"integer\", minimum: 1},\r",
              "                        logo_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                        name: {type: \"string\", minLength: 1},\r",
              "                        origin_country: {type: \"string\"}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            number_of_episodes: {type: \"integer\", minimum: 0},\r",
              "            number_of_seasons: {type: \"integer\", minimum: 0},\r",
              "            origin_country: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"string\"\r",
              "                }\r",
              "            },\r",
              "            original_language: {type: \"string\"},\r",
              "            original_name: {type: \"string\", minLength: 1},\r",
              "            overview: {type: \"string\"},\r",
              "            popularity: {type: \"number\", minimum: 0},\r",
              "            poster_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            production_companies: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"id\", \"name\", \"origin_country\"],\r",
              "                    properties: {\r",
              "                        id: {type: \"integer\", minimum: 1},\r",
              "                        logo_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                        name: {type: \"string\", minLength: 1},\r",
              "                        origin_country: {type: \"string\"}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            production_countries: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"iso_3166_1\", \"name\"],\r",
              "                    properties: {\r",
              "                        iso_3166_1: {type: \"string\", pattern: \"^[A-Z]{2}$\"},\r",
              "                        name: {type: \"string\", minLength: 1}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            seasons: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"episode_count\", \"id\", \"name\", \"season_number\", \"vote_average\"],\r",
              "                    properties: {\r",
              "                        air_date: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                        episode_count: {type: \"integer\", minimum: 0},\r",
              "                        id: {type: \"integer\", minimum: 1},\r",
              "                        name: {type: \"string\", minLength: 1},\r",
              "                        overview: {type: \"string\"},\r",
              "                        poster_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "                        season_number: {type: \"integer\", minimum: 0},\r",
              "                        vote_average: {type: \"number\", minimum: 0, maximum: 10} // Documented as integer, but returns number\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            spoken_languages: {\r",
              "                type: \"array\",\r",
              "                items: {\r",
              "                    type: \"object\",\r",
              "                    required: [\"english_name\", \"iso_639_1\", \"name\"],\r",
              "                    properties: {\r",
              "                        english_name: {type: \"string\", minLength: 1},\r",
              "                        iso_639_1: {type: \"string\", pattern: \"^[a-z]{2}$\"},\r",
              "                        name: {type: \"string\", minLength: 1}\r",
              "                    }\r",
              "                }\r",
              "            },\r",
              "            status: {type: \"string\", minLength: 1},\r",
              "            tagline: {type: \"string\"},\r",
              "            type: {type: \"string\", minLength: 1},\r",
              "            vote_average: {type: \"number\", minimum: 0, maximum: 10},\r",
              "            vote_count: {type: \"integer\", minimum: 0}\r",
              "        }\r",
              "    }\r",
              "}\r",
              "\r",
              "// -----------------------------\r",
              "// DETERMINE DETAIL TYPE\r",
              "// -----------------------------\r",
              "const detailName = pm.variables.get(\"detailName\");\r",
              "\r",
              "if (!detailSchemas[detailName]) {\r",
              "    throw new Error(`No schema defined for detail \"${detailName}\"`);\r",
              "}\r",
              "\r",
              "const detailSchema = detailSchemas[detailName];\r",
              "const validateResult = ajv.compile(detailSchema);\r",
              "\r",
              "const isMovie = detailName === \"movie\";\r",
              "const isTv = detailName === \"tv\";\r",
              "\r",
              "// -----------------------------\r",
              "// PARSE RESPONSE\r",
              "// -----------------------------\r",
              "const jsonData = pm.response.json();\r",
              "\r",
              "// -----------------------------\r",
              "// TRACKING & REGEX VARIABLES\r",
              "// -----------------------------\r",
              "let schemaFailures = [];\r",
              "let dateFailures = [];\r",
              "\r",
              "const iso8601Regex = /^\\d{4}-\\d{2}-\\d{2}$/;\r",
              "\r",
              "// -----------------------------\r",
              "// VALIDATION\r",
              "// -----------------------------\r",
              "// Get stored ID\r",
              "const expectedId = Number(pm.collectionVariables.get(\r",
              "    detailName === \"movie\" ? \"movieId\" : \"tvId\"\r",
              "));\r",
              "\r",
              "// Schema checks\r",
              "const validSchema = validateResult(jsonData);\r",
              "if (!validSchema) {\r",
              "    schemaFailures.push({\r",
              "        detail: detailName,\r",
              "        errors: validateResult.errors\r",
              "    });\r",
              "};\r",
              "\r",
              "// Date validation\r",
              "const datesToCheck = [];\r",
              "\r",
              "if (isMovie) {\r",
              "    datesToCheck.push(\r",
              "        {field: \"release_date\", value: jsonData.release_date}\r",
              "    );\r",
              "}\r",
              "\r",
              "if (isTv) {\r",
              "    datesToCheck.push(\r",
              "        {field: \"first_air_date\", value: jsonData.first_air_date},\r",
              "        {field: \"last_air_date\", value: jsonData.last_air_date},\r",
              "        {field: \"last_episode_to_air.air_date\", value: jsonData.last_episode_to_air?.air_date},\r",
              "        {field: \"next_episode_to_air.air_date\", value: jsonData.next_episode_to_air?.air_date}\r",
              "    );\r",
              "\r",
              "    if (jsonData.seasons) {\r",
              "        jsonData.seasons.forEach((season, index) => {\r",
              "            if (season.air_date && !iso8601Regex.test(season.air_date)) {\r",
              "                dateFailures.push(`seasons[${index}].air_date: ${season.air_date}`);\r",
              "            }\r",
              "        });\r",
              "    }\r",
              "}\r",
              "\r",
              "datesToCheck.forEach(({field, value}) => {\r",
              "    if (value && !iso8601Regex.test(value)) {\r",
              "        dateFailures.push(`${field}: ${value}`);\r",
              "    }\r",
              "});\r",
              "\r",
              "// -----------------------------\r",
              "// TESTS\r",
              "// -----------------------------\r",
              "pm.test(\"Status code is 200\", () => {\r",
              "    pm.response.to.have.status(200);\r",
              "});\r",
              "pm.test(\"Response is JSON\", () => {\r",
              "    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");\r",
              "});\r",
              "pm.test(\"Response ID matches requested ID\", () => {\r",
              "    pm.expect(jsonData.id).to.eql(expectedId);\r",
              "});\r",
              "pm.test(\"All items match expected schema\", () => {\r",
              "    const failureSummary = schemaFailures.map(f =>\r",
              "    `${f.detail}: ${f.errors.map(e => e.message).join(\",\")}`\r",
              "    ).join(\" | \");\r",
              "    pm.expect(schemaFailures.length, failureSummary).to.eql(0);\r",
              "});\r",
              "pm.test(\"All date fields are valid ISO 8601 format\", () => {\r",
              "    pm.expect(dateFailures.length).to.eql(0);\r",
              "});\r",
              "if (isTv) {\r",
              "    pm.test(\"Number of seasons matches seasons list\", () => {\r",
              "        const specialsCount = jsonData.seasons.filter(s => s.season_number === 0).length;\r",
              "        pm.expect(jsonData.number_of_seasons).to.eql(jsonData.seasons.length - specialsCount); // Number of seasons doesn't count specials\r",
              "    });\r",
              "    pm.test(\"Ended TV shows do not have a next episode\", () => {\r",
              "        if (!jsonData.in_production) {\r",
              "            pm.expect(jsonData.next_episode_to_air).to.be.null;\r",
              "        } else {\r",
              "            pm.expect(true).to.be.true; // Show is in production, test not applicable\r",
              "        }\r",
              "    });\r",
              "    pm.test(\"There are more episodes than seasons\", () => {\r",
              "        pm.expect(jsonData.number_of_episodes).to.be.gte(jsonData.number_of_seasons);\r",
              "    })\r",
              "}\r",
              "pm.test(\"Response time is acceptable\", () => {\r",
              "    pm.expect(pm.response.responseTime).to.be.below(500);\r",
              "});\r",
              "\r",
              "// -----------------------------\r",
              "// DEBUG LOGGING\r",
              "// -----------------------------\r",
              "console.log(`Detail test summary for ${detailName}`);\r",
              "console.log(\"Schema failures:\", schemaFailures);\r",
              "console.log(\"Date failures:\", dateFailures);"
            ]
          }
        }
      ]
    },
    {
      "name": "Search",
      "item": [
        {
          "name": "Movie search",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "pm.variables.set(\"searchName\", \"movie\");"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/search/movie?query=the",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "search",
                "movie"
              ],
              "query": [
                {
                  "key": "query",
                  "value": "the"
                }
              ]
            },
            "description": "Returns a list of movies that match the query string. Validates schema, pagination metadata, date formats, and duplicate IDs.\n\nAPI docs: [https://developer.themoviedb.org/reference/search-movie](https://developer.themoviedb.org/reference/search-movie)"
          },
          "response": []
        },
        {
          "name": "TV search",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "pm.variables.set(\"searchName\", \"tv\");"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/search/tv?query=the",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "search",
                "tv"
              ],
              "query": [
                {
                  "key": "query",
                  "value": "the"
                }
              ]
            },
            "description": "Returns a list of TV shows that match the query string. Validates schema, pagination metadata, date formats, and duplicate IDs.\n\nAPI docs: [https://developer.themoviedb.org/reference/search-tv](https://developer.themoviedb.org/reference/search-tv)"
          },
          "response": []
        },
        {
          "name": "No results",
          "event": [
            {
              "listen": "prerequest",
              "script": {
                "exec": [
                  "pm.variables.set(\"searchName\", \"noResults\");"
                ],
                "type": "text/javascript",
                "packages": {},
                "requests": {}
              }
            }
          ],
          "request": {
            "method": "GET",
            "header": [],
            "url": {
              "raw": "https://api.themoviedb.org/3/search/movie?query=lsadkfjaso",
              "protocol": "https",
              "host": [
                "api",
                "themoviedb",
                "org"
              ],
              "path": [
                "3",
                "search",
                "movie"
              ],
              "query": [
                {
                  "key": "query",
                  "value": "lsadkfjaso"
                }
              ]
            },
            "description": "Validates the empty result response returned when no matches are found. Confirms results array, total results, and pagination metadata all reflect a zero-result state."
          },
          "response": []
        }
      ],
      "description": "Tests the movie and TV search endpoints covering schema validation, pagination metadata, date format, duplicate detection, response time, and a no results edge case.",
      "event": [
        {
          "listen": "prerequest",
          "script": {
            "type": "text/javascript",
            "packages": {},
            "requests": {},
            "exec": [
              ""
            ]
          }
        },
        {
          "listen": "test",
          "script": {
            "type": "text/javascript",
            "packages": {},
            "requests": {},
            "exec": [
              "const Ajv = require('ajv');\r",
              "const ajv = new Ajv({ allErrors: true });\r",
              "\r",
              "// -----------------------------\r",
              "// SEARCH SCHEMA DEFINITIONS\r",
              "// -----------------------------\r",
              "const searchSchemas = {\r",
              "\tmovie: {\r",
              "\t\ttype: \"object\",\r",
              "\t\trequired: [\"adult\", \"id\", \"original_language\", \"original_title\", \"overview\", \"popularity\", \"release_date\", \"title\", \"video\", \"vote_average\", \"vote_count\"],\r",
              "\t\tproperties: {\r",
              "            adult: {type: \"boolean\"},\r",
              "            backdrop_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            genre_ids: {type: \"array\", items: {type: \"integer\"}},\r",
              "\t\t\tid: {type: \"integer\", minimum: 1},\r",
              "            original_language: {type: \"string\"},\r",
              "            original_title: {type: \"string\", minLength: 1},\r",
              "            overview: {type: \"string\"},\r",
              "            popularity: {type: \"number\", minimum: 0},\r",
              "            poster_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            release_date: {type: \"string\"},\r",
              "            title: {type: \"string\", minLength: 1},\r",
              "            video: {type: \"boolean\"},\r",
              "            vote_average: {type: \"number\", minimum: 0, maximum: 10},\r",
              "            vote_count: {type: \"integer\", minimum: 0}\r",
              "\t\t}\r",
              "\t},\r",
              "    tv: {\r",
              "\t\ttype: \"object\",\r",
              "\t\trequired: [\"adult\", \"id\", \"origin_country\", \"original_language\", \"original_name\", \"overview\", \"popularity\", \"first_air_date\", \"name\", \"vote_average\", \"vote_count\"],\r",
              "\t\tproperties: {\r",
              "            adult: {type: \"boolean\"},\r",
              "            backdrop_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            genre_ids: {type: \"array\", items: {type: \"integer\"}},\r",
              "\t\t\tid: {type: \"integer\", minimum: 1},\r",
              "            origin_country: {type: \"array\", items: {type: \"string\"}, minItems: 1},\r",
              "            original_language: {type: \"string\"},\r",
              "            original_name: {type: \"string\", minLength: 1},\r",
              "            overview: {type: \"string\"},\r",
              "            popularity: {type: \"number\", minimum: 0},\r",
              "            poster_path: {type: [\"string\", \"null\"]}, // Not documented to allow null, but an observed response\r",
              "            first_air_date: {type: \"string\"},\r",
              "            name: {type: \"string\", minLength: 1},\r",
              "            vote_average: {type: \"number\", minimum: 0, maximum: 10},\r",
              "            vote_count: {type: \"integer\", minimum: 0}\r",
              "\t\t}\r",
              "\t}\r",
              "}\r",
              "\r",
              "// -----------------------------\r",
              "// DETERMINE SEARCH TYPE\r",
              "// -----------------------------\r",
              "const searchName = pm.variables.get(\"searchName\");\r",
              "let validateResult;\r",
              "\r",
              "if (searchName !== \"noResults\") {\r",
              "    if (!searchSchemas[searchName]) {\r",
              "        throw new Error(`No schema defined for search \"${searchName}\"`);\r",
              "    }\r",
              "\r",
              "    const searchSchema = searchSchemas[searchName];\r",
              "    validateResult = ajv.compile(searchSchema);\r",
              "}\r",
              "\r",
              "// -----------------------------\r",
              "// PARSE RESPONSE\r",
              "// -----------------------------\r",
              "const jsonData = pm.response.json();\r",
              "const dataResults = jsonData.results || [];\r",
              "\r",
              "// -----------------------------\r",
              "// TRACKING & REGEX VARIABLES\r",
              "// -----------------------------\r",
              "let totalResults = dataResults.length;\r",
              "let schemaFailures = [];\r",
              "let dateFailures = [];\r",
              "let duplicateIds = [];\r",
              "let idsSeen = new Set();\r",
              "\r",
              "const iso8601Regex = /^\\d{4}-\\d{2}-\\d{2}$/;\r",
              "\r",
              "// -----------------------------\r",
              "// VALIDATION LOOP\r",
              "// -----------------------------\r",
              "if (searchName !== \"noResults\") {\r",
              "    dataResults.forEach(result => {\r",
              "\r",
              "        // Schema checks\r",
              "        const validSchema = validateResult(result);\r",
              "        if (!validSchema) {\r",
              "            schemaFailures.push({\r",
              "                id: result.id,\r",
              "                errors: validateResult.errors\r",
              "            });\r",
              "        }\r",
              "\r",
              "        // Date validation\r",
              "        [\"release_date\", \"first_air_date\"].forEach(field => {\r",
              "            if (result[field] && !iso8601Regex.test(result[field])) {\r",
              "                dateFailures.push(`${result.id} - ${field}: ${result[field]}`);\r",
              "            }\r",
              "        });\r",
              "\r",
              "        // Duplicate detection\r",
              "        if (idsSeen.has(result.id)) {\r",
              "            duplicateIds.push(result.id);\r",
              "        }\r",
              "\r",
              "        idsSeen.add(result.id);\r",
              "    });\r",
              "}\r",
              "\r",
              "// -----------------------------\r",
              "// TESTS\r",
              "// -----------------------------\r",
              "pm.test(\"Status code is 200\", () => {\r",
              "    pm.response.to.have.status(200);\r",
              "});\r",
              "pm.test(\"Response is JSON\", () => {\r",
              "    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");\r",
              "});\r",
              "pm.test(\"Page defaults to 1\", () => {\r",
              "    pm.expect(jsonData.page).to.eql(1);\r",
              "});\r",
              "if (searchName === \"noResults\") {\r",
              "    pm.test(\"Total pages is 1\", () => {\r",
              "        pm.expect(jsonData.total_pages).to.eql(1);\r",
              "    });\r",
              "    pm.test(\"Response contains no results\", () => {\r",
              "        pm.expect(jsonData.results.length).to.eql(0);\r",
              "    });\r",
              "    pm.test(\"Total results is zero\", () => {\r",
              "        pm.expect(jsonData.total_results).to.eql(0);\r",
              "    });\r",
              "} else {\r",
              "    pm.test(\"Total pages is greater than zero\", () => {\r",
              "        pm.expect(jsonData.total_pages).to.be.above(0);\r",
              "    });\r",
              "    pm.test(\"Response contains results\", () => {\r",
              "        pm.expect(jsonData.results.length).to.be.above(0);\r",
              "    });\r",
              "    pm.test(\"Total results is greater than zero\", () => {\r",
              "        pm.expect(jsonData.total_results).to.be.above(0);\r",
              "    });\r",
              "    pm.test(\"No duplicate IDs in search results\", () => {\r",
              "        pm.expect(duplicateIds.length).to.eql(0);\r",
              "    });\r",
              "    pm.test(\"All objects match expected schema\", () => {\r",
              "        const failureSummary = schemaFailures.map(f =>\r",
              "        `ID ${f.id}: ${f.errors.map(e => e.message).join(\",\")}`\r",
              "        ).join(\" | \");\r",
              "        pm.expect(schemaFailures.length, failureSummary).to.eql(0);\r",
              "    });\r",
              "    pm.test(\"All date fields are valid ISO 8601 format\", () => {\r",
              "        pm.expect(dateFailures.length).to.eql(0);\r",
              "    });\r",
              "}\r",
              "pm.test(\"Total results is greater than or equal to results\", () => {\r",
              "    pm.expect(jsonData.total_results).to.be.gte(jsonData.results.length);\r",
              "});\r",
              "pm.test(\"Response time is acceptable\", () => {\r",
              "    pm.expect(pm.response.responseTime).to.be.below(500);\r",
              "});\r",
              "\r",
              "// -----------------------------\r",
              "// DEBUG LOGGING\r",
              "// -----------------------------\r",
              "console.log(`Search test summary for ${searchName}`);\r",
              "console.log(\"Results:\", totalResults);\r",
              "console.log(\"Schema failures:\", schemaFailures);\r",
              "console.log(\"Date failures\", dateFailures);\r",
              "console.log(\"Duplicate IDs:\", duplicateIds);"
            ]
          }
        }
      ]
    }
  ],
  "auth": {
    "type": "bearer",
    "bearer": [
      {
        "key": "token",
        "value": "{{accessToken}}",
        "type": "string"
      }
    ]
  },
  "event": [
    {
      "listen": "prerequest",
      "script": {
        "type": "text/javascript",
        "packages": {},
        "requests": {},
        "exec": [
          ""
        ]
      }
    },
    {
      "listen": "test",
      "script": {
        "type": "text/javascript",
        "packages": {},
        "requests": {},
        "exec": [
          ""
        ]
      }
    }
  ],
  "variable": [
    {
      "key": "movieId",
      "value": ""
    },
    {
      "key": "tvId",
      "value": ""
    }
  ]
}