483 lines
14 KiB
Python
483 lines
14 KiB
Python
import json
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from src.core.parser import OpenAPIParser, ParseError, SpecValidationError
|
|
from src.core.models import OpenAPISpec
|
|
|
|
|
|
class TestOpenAPIParser:
|
|
"""Test cases for OpenAPIParser."""
|
|
|
|
def test_parse_valid_json_spec(self):
|
|
"""Test parsing a valid JSON OpenAPI spec."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
result = parser.parse()
|
|
|
|
assert isinstance(result, OpenAPISpec)
|
|
assert result.openapi == "3.0.0"
|
|
assert result.info.title == "Test API"
|
|
assert result.info.version == "1.0.0"
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_parse_valid_yaml_spec(self):
|
|
"""Test parsing a valid YAML OpenAPI spec."""
|
|
spec_content = """
|
|
openapi: 3.0.0
|
|
info:
|
|
title: Test API
|
|
version: 1.0.0
|
|
paths: {}
|
|
"""
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
|
|
f.write(spec_content)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
result = parser.parse()
|
|
|
|
assert isinstance(result, OpenAPISpec)
|
|
assert result.openapi == "3.0.0"
|
|
assert result.info.title == "Test API"
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_parse_missing_file(self):
|
|
"""Test parsing a non-existent file."""
|
|
parser = OpenAPIParser("nonexistent.json")
|
|
|
|
with pytest.raises(ParseError) as exc_info:
|
|
parser.parse()
|
|
|
|
assert "not found" in str(exc_info.value).lower()
|
|
|
|
def test_parse_invalid_json(self):
|
|
"""Test parsing invalid JSON file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
f.write("{ invalid json }")
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
|
|
with pytest.raises(ParseError):
|
|
parser.parse()
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_parse_invalid_yaml(self):
|
|
"""Test parsing invalid YAML file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
|
|
f.write(" - invalid: yaml: content:")
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
|
|
with pytest.raises(ParseError):
|
|
parser.parse()
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_parse_unsupported_format(self):
|
|
"""Test parsing unsupported file format."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
|
|
f.write("test content")
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
|
|
with pytest.raises(ParseError) as exc_info:
|
|
parser.parse()
|
|
|
|
assert "unsupported" in str(exc_info.value).lower()
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_parse_spec_with_endpoints(self):
|
|
"""Test parsing spec with endpoints."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Pet Store API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {
|
|
"/pets": {
|
|
"get": {
|
|
"summary": "List pets",
|
|
"description": "Get all pets",
|
|
"responses": {
|
|
"200": {"description": "Success"}
|
|
}
|
|
},
|
|
"post": {
|
|
"summary": "Create pet",
|
|
"responses": {
|
|
"201": {"description": "Created"}
|
|
}
|
|
}
|
|
},
|
|
"/pets/{petId}": {
|
|
"get": {
|
|
"summary": "Get pet",
|
|
"parameters": [
|
|
{
|
|
"name": "petId",
|
|
"in": "path",
|
|
"required": True,
|
|
"schema": {"type": "string"}
|
|
}
|
|
],
|
|
"responses": {
|
|
"200": {"description": "Success"},
|
|
"404": {"description": "Not found"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
result = parser.parse()
|
|
|
|
endpoints = result.get_endpoints()
|
|
assert len(endpoints) == 3
|
|
|
|
endpoint_paths = [e.path for e in endpoints]
|
|
assert "/pets" in endpoint_paths
|
|
assert "/pets/{petId}" in endpoint_paths
|
|
|
|
endpoint_methods = [e.method for e in endpoints]
|
|
assert "GET" in endpoint_methods
|
|
assert "POST" in endpoint_methods
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_parse_spec_with_schemas(self):
|
|
"""Test parsing spec with schema definitions."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {},
|
|
"components": {
|
|
"schemas": {
|
|
"Pet": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": {"type": "string"},
|
|
"name": {"type": "string"}
|
|
}
|
|
},
|
|
"User": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": {"type": "integer"},
|
|
"username": {"type": "string"},
|
|
"email": {"type": "string", "format": "email"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
result = parser.parse()
|
|
|
|
schemas = result.get_schemas()
|
|
assert "Pet" in schemas
|
|
assert "User" in schemas
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_parse_spec_with_tags(self):
|
|
"""Test parsing spec with tag definitions."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {},
|
|
"tags": [
|
|
{"name": "pets", "description": "Pet operations"},
|
|
{"name": "users", "description": "User operations"}
|
|
]
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
result = parser.parse()
|
|
|
|
tags = result.get_tags()
|
|
assert len(tags) == 2
|
|
tag_names = [t.name for t in tags]
|
|
assert "pets" in tag_names
|
|
assert "users" in tag_names
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_parse_spec_with_parameters(self):
|
|
"""Test parsing spec with endpoint parameters."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {
|
|
"/items": {
|
|
"get": {
|
|
"summary": "List items",
|
|
"parameters": [
|
|
{
|
|
"name": "limit",
|
|
"in": "query",
|
|
"schema": {"type": "integer"},
|
|
"description": "Max items to return"
|
|
},
|
|
{
|
|
"name": "offset",
|
|
"in": "query",
|
|
"schema": {"type": "integer"},
|
|
"description": "Items to skip"
|
|
}
|
|
],
|
|
"responses": {"200": {"description": "Success"}}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
result = parser.parse()
|
|
|
|
endpoints = result.get_endpoints()
|
|
assert len(endpoints) == 1
|
|
|
|
params = endpoints[0].parameters or []
|
|
assert len(params) == 2
|
|
param_names = [p.name for p in params]
|
|
assert "limit" in param_names
|
|
assert "offset" in param_names
|
|
|
|
Path(f.name).unlink()
|
|
|
|
|
|
class TestSpecValidation:
|
|
"""Test cases for OpenAPI spec validation."""
|
|
|
|
def test_validate_valid_spec(self):
|
|
"""Test validating a valid spec."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
is_valid, errors = parser.validate()
|
|
|
|
assert is_valid is True
|
|
assert len(errors) == 0
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_validate_spec_missing_info(self):
|
|
"""Test validating spec without info section."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"paths": {}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
is_valid, errors = parser.validate()
|
|
|
|
assert is_valid is False
|
|
assert len(errors) > 0
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_validate_spec_missing_paths(self):
|
|
"""Test validating spec without paths section."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
is_valid, errors = parser.validate()
|
|
|
|
assert is_valid is False
|
|
|
|
Path(f.name).unlink()
|
|
|
|
|
|
class TestParseWithExamples:
|
|
"""Test cases for parsing with generated examples."""
|
|
|
|
def test_parse_with_examples(self):
|
|
"""Test parsing spec and generating examples."""
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {
|
|
"/users": {
|
|
"get": {
|
|
"summary": "List users",
|
|
"responses": {
|
|
"200": {
|
|
"description": "Success",
|
|
"content": {
|
|
"application/json": {
|
|
"schema": {
|
|
"type": "array",
|
|
"items": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": {"type": "integer"},
|
|
"name": {"type": "string"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"components": {
|
|
"schemas": {
|
|
"User": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": {"type": "integer"},
|
|
"name": {"type": "string", "format": "email"}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
parser = OpenAPIParser(f.name)
|
|
result = parser.parse_with_examples()
|
|
|
|
assert "spec" in result
|
|
assert "endpoints" in result
|
|
assert "schemas" in result
|
|
|
|
assert len(result["endpoints"]) == 1
|
|
assert len(result["schemas"]) == 1
|
|
|
|
Path(f.name).unlink()
|
|
|
|
|
|
class TestConvenienceFunctions:
|
|
"""Test cases for convenience functions."""
|
|
|
|
def test_parse_spec_file(self):
|
|
"""Test parse_spec_file convenience function."""
|
|
from src.core.parser import parse_spec_file
|
|
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
result = parse_spec_file(f.name)
|
|
|
|
assert isinstance(result, OpenAPISpec)
|
|
assert result.info.title == "Test API"
|
|
|
|
Path(f.name).unlink()
|
|
|
|
def test_validate_spec_file(self):
|
|
"""Test validate_spec_file convenience function."""
|
|
from src.core.parser import validate_spec_file
|
|
|
|
spec = {
|
|
"openapi": "3.0.0",
|
|
"info": {
|
|
"title": "Test API",
|
|
"version": "1.0.0"
|
|
},
|
|
"paths": {}
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump(spec, f)
|
|
f.flush()
|
|
|
|
is_valid, errors = validate_spec_file(f.name)
|
|
|
|
assert is_valid is True
|
|
|
|
Path(f.name).unlink()
|