279 lines
7.6 KiB
Python
279 lines
7.6 KiB
Python
"""CLI interface for API TestGen."""
|
|
|
|
import click
|
|
|
|
from ..core import SpecParser, AuthConfig
|
|
from ..core.exceptions import InvalidOpenAPISpecError, UnsupportedVersionError
|
|
from ..generators import PytestGenerator, JestGenerator, GoGenerator
|
|
from ..mocks import MockServerGenerator
|
|
|
|
|
|
@click.group()
|
|
@click.version_option(version="0.1.0")
|
|
@click.option(
|
|
"--spec",
|
|
"-s",
|
|
type=click.Path(exists=True, file_okay=True, dir_okay=False),
|
|
help="Path to OpenAPI specification file",
|
|
)
|
|
@click.option(
|
|
"--output",
|
|
"-o",
|
|
type=click.Path(file_okay=False, dir_okay=True),
|
|
help="Output directory for generated files",
|
|
)
|
|
@click.option(
|
|
"--mock-url",
|
|
default="http://localhost:4010",
|
|
help="URL of the mock server",
|
|
)
|
|
@click.pass_context
|
|
def main(
|
|
ctx: click.Context,
|
|
spec: str,
|
|
output: str,
|
|
mock_url: str,
|
|
):
|
|
"""API TestGen - Generate integration tests from OpenAPI specifications."""
|
|
ctx.ensure_object(dict)
|
|
ctx.obj["spec"] = spec
|
|
ctx.obj["output"] = output or "./generated"
|
|
ctx.obj["mock_url"] = mock_url
|
|
|
|
|
|
@main.command("parse")
|
|
@click.pass_context
|
|
def parse_spec(ctx: click.Context):
|
|
"""Parse and validate an OpenAPI specification."""
|
|
spec_path = ctx.obj["spec"]
|
|
|
|
if not spec_path:
|
|
click.echo("Error: --spec option is required", err=True)
|
|
raise click.Abort()
|
|
|
|
try:
|
|
parser = SpecParser(spec_path)
|
|
parser.load()
|
|
|
|
info = parser.get_info()
|
|
endpoints = parser.get_endpoints()
|
|
security_schemes = parser.get_security_schemes()
|
|
|
|
click.echo(f"API: {info['title']} v{info['version']}")
|
|
click.echo(f"OpenAPI Version: {parser.version}")
|
|
click.echo(f"Base Path: {parser.base_path}")
|
|
click.echo(f"Endpoints: {len(endpoints)}")
|
|
click.echo(f"Security Schemes: {len(security_schemes)}")
|
|
click.echo()
|
|
|
|
for endpoint in endpoints:
|
|
click.echo(f" {endpoint['method'].upper():6} {endpoint['path']}")
|
|
|
|
ctx.obj["parser"] = parser
|
|
|
|
except InvalidOpenAPISpecError as e:
|
|
click.echo(f"Error: {e}", err=True)
|
|
raise click.Abort()
|
|
except UnsupportedVersionError as e:
|
|
click.echo(f"Error: {e}", err=True)
|
|
raise click.Abort()
|
|
|
|
|
|
@main.command("generate")
|
|
@click.argument("framework", type=click.Choice(["pytest", "jest", "go"]))
|
|
@click.option(
|
|
"--output-file",
|
|
"-f",
|
|
type=click.Path(file_okay=True, dir_okay=False),
|
|
help="Specific output file path",
|
|
)
|
|
@click.option(
|
|
"--package-name",
|
|
default="apitest",
|
|
help="Go package name (only for go framework)",
|
|
)
|
|
@click.pass_context
|
|
def generate_tests(
|
|
ctx: click.Context,
|
|
framework: str,
|
|
output_file: str,
|
|
package_name: str,
|
|
):
|
|
"""Generate test files for a framework (pytest, jest, or go)."""
|
|
spec_path = ctx.obj["spec"]
|
|
|
|
if not spec_path:
|
|
click.echo("Error: --spec option is required", err=True)
|
|
raise click.Abort()
|
|
|
|
output_dir = ctx.obj["output"]
|
|
mock_url = ctx.obj["mock_url"]
|
|
|
|
try:
|
|
parser = SpecParser(spec_path)
|
|
parser.load()
|
|
|
|
if framework == "pytest":
|
|
generator = PytestGenerator(parser, output_dir, mock_url)
|
|
files = generator.generate(output_file)
|
|
|
|
elif framework == "jest":
|
|
generator = JestGenerator(parser, output_dir, mock_url)
|
|
files = generator.generate(output_file)
|
|
|
|
elif framework == "go":
|
|
generator = GoGenerator(parser, output_dir, mock_url, package_name)
|
|
files = generator.generate(output_file)
|
|
|
|
click.echo(f"Generated {len(files)} test file(s):")
|
|
for f in files:
|
|
click.echo(f" - {f}")
|
|
|
|
except Exception as e:
|
|
click.echo(f"Error: {e}", err=True)
|
|
raise click.Abort()
|
|
|
|
|
|
@main.command("mock")
|
|
@click.option(
|
|
"--no-prism-config",
|
|
is_flag=True,
|
|
help="Skip generating prism-config.json",
|
|
)
|
|
@click.option(
|
|
"--no-docker-compose",
|
|
is_flag=True,
|
|
help="Skip generating docker-compose.yml",
|
|
)
|
|
@click.option(
|
|
"--no-dockerfile",
|
|
is_flag=True,
|
|
help="Skip generating Dockerfile",
|
|
)
|
|
@click.pass_context
|
|
def generate_mock(
|
|
ctx: click.Context,
|
|
no_prism_config: bool,
|
|
no_docker_compose: bool,
|
|
no_dockerfile: bool,
|
|
):
|
|
"""Generate mock server configuration files."""
|
|
spec_path = ctx.obj["spec"]
|
|
|
|
if not spec_path:
|
|
click.echo("Error: --spec option is required", err=True)
|
|
raise click.Abort()
|
|
|
|
output_dir = ctx.obj["output"]
|
|
|
|
try:
|
|
parser = SpecParser(spec_path)
|
|
parser.load()
|
|
|
|
generator = MockServerGenerator(parser, output_dir)
|
|
|
|
files = generator.generate(
|
|
prism_config=not no_prism_config,
|
|
docker_compose=not no_docker_compose,
|
|
dockerfile=not no_dockerfile,
|
|
)
|
|
|
|
click.echo(f"Generated {len(files)} mock server file(s):")
|
|
for f in files:
|
|
click.echo(f" - {f}")
|
|
|
|
except Exception as e:
|
|
click.echo(f"Error: {e}", err=True)
|
|
raise click.Abort()
|
|
|
|
|
|
@main.command("all")
|
|
@click.argument("framework", type=click.Choice(["pytest", "jest", "go"]))
|
|
@click.pass_context
|
|
def generate_all(
|
|
ctx: click.Context,
|
|
framework: str,
|
|
):
|
|
"""Generate test files and mock server configuration."""
|
|
spec_path = ctx.obj["spec"]
|
|
|
|
if not spec_path:
|
|
click.echo("Error: --spec option is required", err=True)
|
|
raise click.Abort()
|
|
|
|
output_dir = ctx.obj["output"]
|
|
mock_url = ctx.obj["mock_url"]
|
|
|
|
try:
|
|
parser = SpecParser(spec_path)
|
|
parser.load()
|
|
|
|
click.echo("Generating tests...")
|
|
if framework == "pytest":
|
|
generator = PytestGenerator(parser, output_dir, mock_url)
|
|
files = generator.generate()
|
|
|
|
elif framework == "jest":
|
|
generator = JestGenerator(parser, output_dir, mock_url)
|
|
files = generator.generate()
|
|
|
|
elif framework == "go":
|
|
generator = GoGenerator(parser, output_dir, mock_url)
|
|
files = generator.generate()
|
|
|
|
click.echo(f"Generated {len(files)} test file(s)")
|
|
|
|
click.echo("Generating mock server configuration...")
|
|
mock_generator = MockServerGenerator(parser, output_dir)
|
|
mock_files = mock_generator.generate()
|
|
|
|
click.echo(f"Generated {len(mock_files)} mock server file(s)")
|
|
|
|
click.echo("\nAll files generated successfully!")
|
|
|
|
except Exception as e:
|
|
click.echo(f"Error: {e}", err=True)
|
|
raise click.Abort()
|
|
|
|
|
|
@main.command("auth")
|
|
@click.argument("scheme_name")
|
|
@click.option(
|
|
"--type",
|
|
"auth_type",
|
|
type=click.Choice(["apiKey", "bearer", "basic"]),
|
|
help="Authentication type",
|
|
)
|
|
@click.option("--header", help="Header name for API key", default="X-API-Key")
|
|
@click.option("--token", help="Bearer token or API key value")
|
|
@click.option("--username", help="Username for Basic auth")
|
|
@click.option("--password", help="Password for Basic auth")
|
|
@click.pass_context
|
|
def configure_auth(
|
|
ctx: click.Context,
|
|
scheme_name: str,
|
|
auth_type: str,
|
|
header: str,
|
|
token: str,
|
|
username: str,
|
|
password: str,
|
|
):
|
|
"""Configure authentication for a security scheme."""
|
|
auth_config = AuthConfig()
|
|
|
|
if auth_type == "apiKey":
|
|
auth_config.add_api_key(scheme_name, header, token or "")
|
|
elif auth_type == "bearer":
|
|
auth_config.add_bearer(scheme_name, token or "")
|
|
elif auth_type == "basic":
|
|
auth_config.add_basic(scheme_name, username or "", password or "")
|
|
|
|
click.echo(f"Authentication scheme '{scheme_name}' configured:")
|
|
methods = auth_config.get_all_methods()
|
|
for name, method in methods.items():
|
|
click.echo(f" - {name}: {method['type'].value}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|