Compare commits

...

41 Commits

Author SHA1 Message Date
maxime 9f908d3cee
[release] halfapi 0.6.30 2024-05-28 02:55:17 +02:00
maxime 7b6d9e994a
[deps] starlette v0.37 2024-05-28 02:54:50 +02:00
maxime 8f6330bca7
[deps] starlette 0.35 2024-05-28 02:53:58 +02:00
maxime 8506aa5322
[middleware] fix DomainMiddleware constructor for 0.35 2024-05-28 02:41:41 +02:00
maxime b683e80959
[halfapi] remove on_startup argument according to starlette 0.26 2024-05-28 02:41:19 +02:00
maxime b412d249a1
[deps] bump dependencies versions 2024-05-28 02:39:08 +02:00
Maxime Alves LIRMM f4f9a0fc66 [dockerfile] alpine 3.19 - utilisation d'un venv 2023-12-13 11:37:29 +01:00
Maxime Alves LIRMM c855cce013 [release] 0.6.29 2023-12-13 11:09:42 +01:00
Maxime Alves LIRMM e083c4386e [release] 0.6.28 2023-11-24 14:31:10 +01:00
Maxime Alves LIRMM 476ae29792 [rc] 0.6.28rc5 2023-09-01 04:59:17 +09:00
Maxime Alves LIRMM 673097adeb [half_domain] fix ACL route when checked ACL is a decorator 2023-09-01 04:58:12 +09:00
Maxime Alves LIRMM 1cc1bbd5ef [rc] 0.6.28rc4 (remove rc3) 2023-08-21 08:47:47 +02:00
Maxime Alves LIRMM 135d6e86e4 [conf] fix export SECRET variable 2023-08-21 08:47:19 +02:00
Maxime Alves LIRMM 0fcf433ec6 [ci] use alpine base image directly 2023-08-21 00:08:29 +02:00
Maxime Alves LIRMM 45cf32de2b [ci] utilisation de l'image 3.17 (pour fix le bug exceptiongroup) 2023-08-20 23:53:18 +02:00
Maxime Alves LIRMM 1b713c3816 [ci] fix image pour les tests <3.11 2023-08-20 23:42:10 +02:00
Maxime Alves LIRMM 59889e1e31 [ci] pipenv --skip-lock (has been remove) 2023-08-20 23:34:34 +02:00
Maxime Alves LIRMM 28a1a69435 [rc] 0.6.28rc3 - fix bugs and general configuration management cleanup (see changelog) 2023-08-20 23:32:50 +02:00
maxime 65ecf9817c [ci/Dockerfile] use of alpine OS instead of debian, bump python to version 3.11 2023-08-09 14:46:52 +02:00
maxime 3b7d3bda5c [rc] 0.6.28rc2 2023-08-09 14:24:32 +02:00
maxime e19f27f306 [deps] starlette 0.31 2023-08-09 14:23:09 +02:00
maxime e9c84c9f7c [rc] 0.6.28-rc1 2023-08-08 09:09:16 +02:00
maxime b1595beb14 [tests] write a schema component for dummy_domain for example 2023-08-02 13:29:57 +02:00
maxime 60ff99d0fb [domain] you can specify Schema components under the "schema_components" key of the domain dictionary 2023-08-02 12:55:04 +02:00
maxime 9657f0f9ec [ci-cd] add python 3.11 to testing releases 2023-08-02 10:57:33 +02:00
maxime f646b4d663 [ci-cd] coverage report 2023-08-02 10:49:54 +02:00
maxime 0817882558 [dev-deps] ajout de la dépendance a coverage 2023-08-02 10:43:50 +02:00
maxime 896ce58731 [pytest] do not avoid to run doctest modules in halfapi sources! 2023-08-02 10:39:06 +02:00
maxime 87856cfb42 [cli-conf] halfapi domain : the file provided as argument is a toml file of the format of .halfapi/config, + better config handling 2023-08-02 10:38:36 +02:00
maxime 4856f80b99 [rc] 0.6.28-rc0-1 2023-08-02 06:32:26 +02:00
maxime eac602f0a5 [rc] 0.6.28rc0 2023-08-01 20:50:58 +02:00
maxime 14e051bd91 [doc-schema] the "/" route on a domain now returns the OpenAPI-validated Schema (not a list of schemas), the "dummy_domain" test now validates OpenAPI specs 2023-08-01 20:31:17 +02:00
maxime 20563081f5 [doc-schema] In module-based routers, if there is a path parameter, you can specify an OpenAPI documentation for it, or a default will be used 2023-08-01 20:24:24 +02:00
maxime 7949b3206c [dev-deps] openapi-schema-validator, openapi-spec-validator 2023-08-01 19:41:49 +02:00
maxime c4583b7187 [doc] add docstrings for halfapi routes 2023-08-01 17:43:59 +02:00
maxime 2413436104 [acl] The public acls check routes use the "HEAD" method, deprecated "GET" 2023-08-01 17:32:25 +02:00
Maxime Alves LIRMM 54cc6c17c9 [release] 0.6.27 2023-06-07 11:46:53 +02:00
Maxime Alves LIRMM ff3a39c740 [rc] 0.6.27rc0 2023-06-01 15:39:57 +02:00
Maxime Alves LIRMM@home 8d254bafa0 [feature] changes in the ACLs result availability 2023-06-01 15:39:44 +02:00
Maxime Alves LIRMM 0a385661b9 [rc] 0.6.26rc0 2023-02-23 11:44:57 +01:00
Maxime Alves LIRMM e065fe04e4 [tests] test with multiple optional parameteres 2023-02-21 19:30:59 +01:00
38 changed files with 1708 additions and 868 deletions

View File

@ -6,7 +6,7 @@
# Official language image. Look for the different tagged releases at:
# https://hub.docker.com/r/library/python/tags/
image: python:3.9-bullseye
image: python:alpine3.18
# Change pip's cache directory to be inside the project directory since we can
# only cache local items.
@ -33,39 +33,43 @@ stages:
.before_script_template: &test
before_script:
- apt-get update && apt-get -y install python3-venv
- python3 -V # Print out python version for debugging
- pip3 install pipenv
- pipenv install --dev --skip-lock
- python3 -m venv /tmp/venv
- /tmp/venv/bin/pip3 install .["tests","pyexcel"]
- /tmp/venv/bin/pip3 install coverage pytest
test:
image: python:${PYVERSION}-bullseye
image: python:alpine${ALPINEVERSION}
stage: test
<<: *test
parallel:
matrix:
- PYVERSION: ["3.7", "3.8", "3.9", "3.10"]
- ALPINEVERSION: ["3.16", "3.17", "3.18", "3.19"]
script:
- pipenv run pytest --version
- PYTHONPATH=./tests/ pipenv run pytest -v ./tests
- pipenv run halfapi --version
- /tmp/venv/bin/pytest --version
- PYTHONPATH=./tests/ /tmp/venv/bin/coverage run --source halfapi -m pytest
- /tmp/venv/bin/coverage xml
- /tmp/venv/bin/halfapi --version
artifacts:
reports:
coverage_report:
coverage_format: cobertura
path: coverage.xml
build_pypi:
stage: build
script:
- apt-get update && apt-get -y install python3-venv
- python3 -V # Print out python version for debugging
- pip3 install pipenv
- pipenv install --dev --skip-lock
- pipenv run python -m build --sdist
- pipenv run python -m build --wheel
- python3 -m venv /tmp/venv
- /tmp/venv/bin/pip3 install .
artifacts:
paths:
- dist/*.whl
rules:
- if: '$CI_COMMIT_TAG != ""'
variables:
TAG: $CI_COMMIT_TAG
TAG: $CI_COMMIT_TAG
build_container:
rules:
@ -73,7 +77,7 @@ build_container:
variables:
IMGTAG: $CI_COMMIT_TAG
- if: '$CI_COMMIT_REF_NAME == "devel"'
variables:
variables:
IMGTAG: "latest"
stage: build
image: $CI_REGISTRY/devtools/kaniko

View File

@ -1,5 +1,113 @@
# HalfAPI
## 0.6.30
Dependencies updates
- pyYAML v6.0.1
- starlette v0.37.2
Warning : the on_startup halfAPI argument is now removed, use the lifeSpan
## 0.6.29
### Dependencies
Starlette version bumped to 0.33.
## 0.6.28
### Dependencies
Starlette version bumped to 0.31 (had to disable a test to make it work but
seems not important).
### Development dependencies
Python 3.7 is no longer supported (openapi_spec_validator is not compatible).
If you are a developper, you should update dev dependencies in your virtual
environment.
### OpenAPI schemas
This release improves OpenAPI specification in routes, and gives a default
"parameters" field for routes that have path parameters.
Also, if you use halfAPI for multi-domain setups, you may be annoyed by the
change in the return value of the "/" route that differs from "/domain" route.
An HalfAPI instance should return one and only one OpenAPI Schema, so you can
rely on it to connect to other software.
The version number that is contained under the "info" dictionnary is now the "version"
of the Api domain, as specified in the domain dictionnary specified at the root
of the Domain.
The title field of the "info" dictionnary is now the Domain's name.
The ACLs list is now available under the "info.x-acls" attribute of the schema.
It is still accessible from the "/halfapi/acls" route.
#### Schema Components
You can now specify a dict in the domain's metadata dict that follows the
"components" key of an OpenAPI schema.
Use it to define models that are used in your API. You can see an exemple of
it's use in the "tests/dummy_domain/__init__.py" file.
### ACLs
The use of an "HEAD" request to check an ACL is now the norm. Please change all
the occurrences of your calls on theses routes with the GET method.
### CLI
Domain command update :
The `--conftest` flag is now allowed when running the `domain` command, it dumps the current configuration as a TOML string.
`halfapi domain --conftest my_domain`
The `--dry-run` flag was buggy and is now fixed when using the `domai ` command with the `--run` flag.
### Configuration
The `port` option in a `domain.my_domain` section in the TOML config file is now prefered to the one in the `project` section.
The `project` section is used as a default section for the whole configuration file. - Tests still have to be written -
The standard configuration precedence is fixed, in this order from the hight to the lower :
- Argument value (i.e. : --log-level)
- Environment value (i.e. : HALFAPI_LOGLEVEL)
- Configuration value under "domain" key
- Configuration value under "project" key
- Default configuration value given in the "DEFAULT_CONF" dictionary of halfapi/conf.py
### Logs
Small cleanup of the logs levels. If you don't want the config to be dumped, just set the HALFAPI_LOGLEVEL to something different than "DEBUG".
### Fixes
- Check an ACL based on a decorator on "/halfapi/acls/MY_ACL"
## 0.6.27
### Breaking changes
- ACLs definition can now include a "public" parameter that defines if there should be an automatic creation of a route to check this acls
- /halfapi/acls does not return the "result", it just returns if there is a public route to check the ACL on /halfapi/acls/acl_name
=======
argument of starlette instead.
>>>>>>> a8c59c6 ([release] halfapi 0.6.27)
## 0.6.26
- Adds the "base_url", "cookies" and "url" to the "halfapi" argument of route definitions

View File

@ -1,9 +1,11 @@
# syntax=docker/dockerfile:1
FROM docker.io/python:3.10.5-slim-bullseye
FROM python:alpine3.19
COPY . /halfapi
WORKDIR /halfapi
RUN apt-get update > /dev/null && apt-get -y install git > /dev/null
RUN pip install gunicorn uvicorn
RUN pip install .
CMD gunicorn halfapi.app
ENV VENV_DIR=/opt/venv
RUN mkdir -p $VENV_DIR
RUN python -m venv $VENV_DIR
RUN $VENV_DIR/bin/pip install gunicorn uvicorn
RUN $VENV_DIR/bin/pip install .
RUN ln -s $VENV_DIR/bin/halfapi /usr/local/bin/
CMD $VENV_DIR/bin/gunicorn halfapi.app

View File

@ -14,14 +14,17 @@ pyflakes = "*"
vulture = "*"
virtualenv = "*"
httpx = "*"
openapi-schema-validator = "*"
openapi-spec-validator = "*"
coverage = "*"
[packages]
click = ">=8,<9"
starlette = ">=0.23,<0.24"
starlette = ">=0.37,<0.38"
uvicorn = ">=0.13,<1"
orjson = ">=3.8.5,<4"
pyjwt = ">=2.6.0,<2.7.0"
pyyaml = ">=6,<7"
pyyaml = ">=6.0.1,<7"
timing-asgi = ">=0.2.1,<1"
schema = ">=0.7.4,<1"
toml = ">=0.10,<0.11"

1479
Pipfile.lock generated

File diff suppressed because it is too large Load Diff

View File

@ -1,5 +1,5 @@
#!/usr/bin/env python3
__version__ = '0.6.26'
__version__ = '0.6.30'
def version():
return f'HalfAPI version:{__version__}'

View File

@ -1,9 +1,7 @@
import os
from .halfapi import HalfAPI
from .conf import CONFIG, SCHEMA
from .logging import logger
logger.info('CONFIG: %s', CONFIG)
logger.info('SCHEMA: %s', SCHEMA)
application = HalfAPI(
CONFIG, SCHEMA or None).application
def application():
from .conf import CONFIG
return HalfAPI(CONFIG).application

View File

@ -9,6 +9,7 @@ import importlib
import subprocess
import json
import toml
import click
import orjson
@ -22,6 +23,7 @@ from ..half_domain import HalfDomain
from ..lib.routes import api_routes
from ..lib.responses import ORJSONResponse
from ..conf import CONFIG, PROJECT_LEVEL_KEYS
from ..logging import logger
@ -119,16 +121,22 @@ def list_api_routes():
# list_routes(domain, m_dom)
@click.option('--devel',default=None, is_flag=True)
@click.option('--watch',default=False, is_flag=True)
@click.option('--production',default=None, is_flag=True)
@click.option('--port',default=None, type=int)
@click.option('--log-level',default=None, type=str)
@click.option('--dry-run',default=False, is_flag=True)
@click.option('--run',default=False, is_flag=True)
@click.option('--read',default=False, is_flag=True)
@click.option('--conftest',default=False, is_flag=True)
@click.option('--create',default=False, is_flag=True)
@click.option('--update',default=False, is_flag=True)
@click.option('--delete',default=False, is_flag=True)
@click.argument('config_file', type=click.File(mode='rb'), required=False)
@click.argument('domain',default=None, required=False)
@cli.command()
def domain(domain, config_file, delete, update, create, read, run, dry_run): #, domains, read, create, update, delete):
def domain(domain, config_file, delete, update, create, conftest, read, run, dry_run, log_level, port, production, watch, devel):
"""
The "halfapi domain" command
@ -145,6 +153,22 @@ def domain(domain, config_file, delete, update, create, read, run, dry_run): #,
# TODO: Connect to the create_domain function
raise NotImplementedError
raise Exception('Missing domain name')
if config_file:
ARG_CONFIG = toml.load(config_file.name)
if 'project' in ARG_CONFIG:
for key, value in ARG_CONFIG['project'].items():
if key in PROJECT_LEVEL_KEYS:
CONFIG[key] = value
if 'domain' in ARG_CONFIG and domain in ARG_CONFIG['domain']:
for key, value in ARG_CONFIG['domain'][domain].items():
if key in PROJECT_LEVEL_KEYS:
CONFIG[key] = value
CONFIG['domain'].update(ARG_CONFIG['domain'])
if create:
raise NotImplementedError
elif update:
@ -152,14 +176,8 @@ def domain(domain, config_file, delete, update, create, read, run, dry_run): #,
elif delete:
raise NotImplementedError
elif read:
from ..conf import CONFIG
from ..halfapi import HalfAPI
if config_file:
CONFIG = json.loads(''.join(
[ line.decode() for line in config_file.readlines() ]
))
halfapi = HalfAPI(CONFIG)
click.echo(orjson.dumps(
halfapi.domains[domain].schema(),
@ -168,26 +186,57 @@ def domain(domain, config_file, delete, update, create, read, run, dry_run): #,
)
else:
from ..conf import CONFIG
if 'domain' not in CONFIG:
CONFIG['domain'] = {}
if domain not in CONFIG['domain']:
CONFIG['domain'][domain] = {
'enabled': True,
'name': domain
}
if dry_run:
CONFIG['dryrun'] = True
CONFIG['domain'][domain]['enabled'] = True
port = CONFIG['domain'][domain].get('port', 3000)
domains = CONFIG.get('domain')
for key in domains.keys():
if key != domain:
domains[key]['enabled'] = False
else:
domains[key]['enabled'] = True
uvicorn.run(
'halfapi.app:application',
port=port
)
if not log_level:
log_level = CONFIG.get('domain', {}).get('loglevel', CONFIG.get('loglevel', False))
else:
CONFIG['loglevel'] = log_level
if not port:
port = CONFIG.get('domain', {}).get('port', CONFIG.get('port', False))
else:
CONFIG['port'] = port
if devel is None and production is not None and (production is False or production is True):
CONFIG['production'] = production
if devel is not None:
CONFIG['production'] = False
CONFIG['loglevel'] = 'debug'
if conftest:
click.echo(
toml.dumps(CONFIG)
)
else:
# domain section port is preferred, if it doesn't exist we use the global one
uvicorn_kwargs = {}
if CONFIG.get('port'):
uvicorn_kwargs['port'] = CONFIG['port']
if CONFIG.get('loglevel'):
uvicorn_kwargs['log_level'] = CONFIG['loglevel'].lower()
if watch:
uvicorn_kwargs['reload'] = True
uvicorn.run(
'halfapi.app:application',
factory=True,
**uvicorn_kwargs
)
sys.exit(0)

View File

@ -36,7 +36,7 @@ It follows the following format :
"""
import logging
from .logging import logger
import os
from os import environ
import sys
@ -46,21 +46,51 @@ import uuid
import toml
from .logging import logger
PRODUCTION = True
LOGLEVEL = 'info'
CONF_FILE = os.environ.get('HALFAPI_CONF_FILE', '.halfapi/config')
DRYRUN = bool(os.environ.get('HALFAPI_DRYRUN', False))
SCHEMA = {}
CONF_DIR = environ.get('HALFAPI_CONF_DIR', '/etc/half_api')
DEFAULT_CONF = {
# Default configuration values
'SECRET': tempfile.mkstemp()[1],
'PROJECT_NAME': os.getcwd().split('/')[-1],
'PRODUCTION': True,
'HOST': '127.0.0.1',
'PORT': 3000,
'LOGLEVEL': 'info',
'BASE_DIR': os.getcwd(),
'CONF_FILE': '.halfapi/config',
'CONF_DIR': '/etc/half_api',
'DRYRUN': None
}
PROJECT_LEVEL_KEYS = {
# Allowed keys in "project" section of configuration file
'project_name',
'production',
'secret',
'host',
'port',
'loglevel',
'dryrun'
}
DOMAIN_LEVEL_KEYS = PROJECT_LEVEL_KEYS | {
# Allowed keys in "domain" section of configuration file
'name',
'module',
'prefix',
'enabled'
}
CONF_FILE = os.environ.get('HALFAPI_CONF_FILE', DEFAULT_CONF['CONF_FILE'])
CONF_DIR = os.environ.get('HALFAPI_CONF_DIR', DEFAULT_CONF['CONF_DIR'])
HALFAPI_ETC_FILE=os.path.join(
CONF_DIR, 'config'
)
BASE_DIR = os.environ.get('HALFAPI_BASE_DIR', DEFAULT_CONF['BASE_DIR'])
HALFAPI_DOT_FILE=os.path.join(
os.getcwd(), '.halfapi', 'config')
BASE_DIR, '.halfapi', 'config')
HALFAPI_CONFIG_FILES = []
@ -68,35 +98,61 @@ try:
with open(HALFAPI_ETC_FILE, 'r'):
HALFAPI_CONFIG_FILES.append(HALFAPI_ETC_FILE)
except FileNotFoundError:
logger.error('Cannot find a configuration file under %s', HALFAPI_DOT_FILE)
logger.info('Cannot find a configuration file under %s', HALFAPI_ETC_FILE)
try:
with open(HALFAPI_DOT_FILE, 'r'):
HALFAPI_CONFIG_FILES.append(HALFAPI_DOT_FILE)
except FileNotFoundError:
logger.error('Cannot find a configuration file under %s', HALFAPI_DOT_FILE)
logger.info('Cannot find a configuration file under %s', HALFAPI_DOT_FILE)
def read_config():
ENVIRONMENT = {}
# Load environment variables allowed in configuration
if 'HALFAPI_DRYRUN' in os.environ:
ENVIRONMENT['dryrun'] = True
if 'HALFAPI_PROD' in os.environ:
ENVIRONMENT['production'] = bool(os.environ.get('HALFAPI_PROD'))
if 'HALFAPI_LOGLEVEL' in os.environ:
ENVIRONMENT['loglevel'] = os.environ.get('HALFAPI_LOGLEVEL').lower()
if 'HALFAPI_SECRET' in os.environ:
ENVIRONMENT['secret'] = os.environ.get('HALFAPI_SECRET')
if 'HALFAPI_HOST' in os.environ:
ENVIRONMENT['host'] = os.environ.get('HALFAPI_HOST')
if 'HALFAPI_PORT' in os.environ:
ENVIRONMENT['port'] = int(os.environ.get('HALFAPI_PORT'))
def read_config(filenames=HALFAPI_CONFIG_FILES):
"""
The highest index in "filenames" are the highest priorty
"""
d_res = {}
logger.info('Reading config files %s', HALFAPI_CONFIG_FILES)
for CONF_FILE in HALFAPI_CONFIG_FILES:
d_res.update( toml.load(HALFAPI_CONFIG_FILES) )
logger.info('Reading config files %s', filenames)
for CONF_FILE in filenames:
if os.path.isfile(CONF_FILE):
conf_dict = toml.load(CONF_FILE)
d_res.update(conf_dict)
logger.info('Reading config files (result) %s', d_res)
logger.info('Read config files (result) %s', d_res)
return { **d_res.get('project', {}), 'domain': d_res.get('domain', {}) }
CONFIG = read_config()
CONFIG.update(**ENVIRONMENT)
PROJECT_NAME = CONFIG.get('project_name',
environ.get('HALFAPI_PROJECT_NAME', os.getcwd().split('/')[-1]))
os.environ.get('HALFAPI_PROJECT_NAME', DEFAULT_CONF['PROJECT_NAME']))
if environ.get('HALFAPI_DOMAIN_NAME'):
DOMAIN_NAME = environ.get('HALFAPI_DOMAIN_NAME')
if os.environ.get('HALFAPI_DOMAIN_NAME'):
# Force enabled domain by environment variable
DOMAIN_NAME = os.environ.get('HALFAPI_DOMAIN_NAME')
if 'domain' in CONFIG and DOMAIN_NAME in CONFIG['domain'] \
and 'config' in CONFIG['domain'][DOMAIN_NAME]:
@ -114,53 +170,36 @@ if environ.get('HALFAPI_DOMAIN_NAME'):
CONFIG['domain'][DOMAIN_NAME]['config'] = domain_config
if environ.get('HALFAPI_DOMAIN_MODULE'):
dom_module = environ.get('HALFAPI_DOMAIN_MODULE')
if os.environ.get('HALFAPI_DOMAIN_MODULE'):
# Specify the pythonpath to import the specified domain (defaults to global)
dom_module = os.environ.get('HALFAPI_DOMAIN_MODULE')
CONFIG['domain'][DOMAIN_NAME]['module'] = dom_module
if len(CONFIG.get('domain', {}).keys()) == 0:
logger.info('No domains')
# Bind
HOST = CONFIG.get('host',
environ.get('HALFAPI_HOST', '127.0.0.1'))
PORT = int(CONFIG.get(
'port',
environ.get('HALFAPI_PORT', '3000')))
# Secret
SECRET = CONFIG.get(
'secret',
environ.get('HALFAPI_SECRET'))
if not SECRET:
if 'secret' not in CONFIG:
# TODO: Create a temporary secret
_, SECRET = tempfile.mkstemp()
with open(SECRET, 'w') as secret_file:
CONFIG['secret'] = DEFAULT_CONF['SECRET']
with open(CONFIG['secret'], 'w') as secret_file:
secret_file.write(str(uuid.uuid4()))
try:
with open(SECRET, 'r') as secret_file:
CONFIG['secret'] = SECRET.strip()
with open(CONFIG['secret'], 'r') as secret_file:
CONFIG['secret'] = CONFIG['secret'].strip()
except FileNotFoundError as exc:
logger.info('Running without secret file: %s', SECRET or 'no file specified')
logger.warning('Running without secret file: %s', CONFIG['secret'] or 'no file specified')
PRODUCTION = bool(CONFIG.get(
'production',
environ.get('HALFAPI_PROD', True)))
CONFIG.setdefault('project_name', DEFAULT_CONF['PROJECT_NAME'])
CONFIG.setdefault('production', DEFAULT_CONF['PRODUCTION'])
CONFIG.setdefault('host', DEFAULT_CONF['HOST'])
CONFIG.setdefault('port', DEFAULT_CONF['PORT'])
CONFIG.setdefault('loglevel', DEFAULT_CONF['LOGLEVEL'])
CONFIG.setdefault('dryrun', DEFAULT_CONF['DRYRUN'])
LOGLEVEL = CONFIG.get(
'loglevel',
environ.get('HALFAPI_LOGLEVEL', 'info')).lower()
BASE_DIR = CONFIG.get(
'base_dir',
environ.get('HALFAPI_BASE_DIR', '.'))
CONFIG['project_name'] = PROJECT_NAME
CONFIG['production'] = PRODUCTION
CONFIG['secret'] = SECRET
CONFIG['host'] = HOST
CONFIG['port'] = PORT
CONFIG['dryrun'] = DRYRUN
# !!!TO REMOVE!!!
SECRET = CONFIG.get('secret')
PRODUCTION = CONFIG.get('production')
# !!!

View File

@ -11,7 +11,11 @@ from types import ModuleType, FunctionType
from schema import SchemaError
from starlette.applications import Starlette
from starlette.routing import Router
from starlette.middleware import Middleware
from starlette.routing import Router, Route
from starlette.schemas import SchemaGenerator
from .lib.acl import AclRoute
import yaml
@ -19,8 +23,10 @@ import yaml
from . import __version__
from .lib.constants import API_SCHEMA_DICT, ROUTER_SCHEMA, VERBS
from .half_route import HalfRoute
from .lib import acl
from .lib import acl as lib_acl
from .lib.responses import PlainTextResponse
from .lib.routes import JSONRoute
from .lib.schemas import param_docstring_default
from .lib.domain import MissingAclError, PathError, UnknownPathParameterType, \
UndefinedRoute, UndefinedFunction, get_fct_name, route_decorator
from .lib.domain_middleware import DomainMiddleware
@ -38,15 +44,16 @@ class HalfDomain(Starlette):
self.app = app
self.m_domain = importlib.import_module(domain) if module is None else module
d_domain = getattr(self.m_domain, 'domain', domain)
self.name = d_domain['name']
self.id = d_domain['id']
self.version = d_domain['version']
self.halfapi_version = d_domain.get('halfapi_version', __version__)
self.deps = d_domain.get('deps', tuple())
self.d_domain = getattr(self.m_domain, 'domain', domain)
self.name = self.d_domain['name']
self.id = self.d_domain['id']
self.version = self.d_domain['version']
self.halfapi_version = self.d_domain.get('halfapi_version', __version__)
self.deps = self.d_domain.get('deps', tuple())
self.schema_components = self.d_domain.get('schema_components', dict())
if not router:
self.router = d_domain.get('routers', '.routers')
self.router = self.d_domain.get('routers', '.routers')
else:
self.router = router
@ -76,18 +83,26 @@ class HalfDomain(Starlette):
super().__init__(
routes=self.gen_domain_routes(),
middleware=[
(DomainMiddleware, {
'domain': {
Middleware(
DomainMiddleware,
domain={
'name': self.name,
'id': self.id,
'version': self.version,
'halfapi_version': self.halfapi_version,
'config': self.config.get('domain', {}).get(self.name, {}).get('config', {})
}
})
)
]
)
@staticmethod
def name(module):
""" Returns the name declared in the 'domain' dict at the root of the package
"""
return module.domain['name']
@staticmethod
def m_acl(module, acl=None):
""" Returns the imported acl module for the domain module
@ -104,9 +119,14 @@ class HalfDomain(Starlette):
"""
m_acl = HalfDomain.m_acl(module, acl)
try:
return getattr(m_acl, 'ACLS')
except AttributeError:
raise Exception(f'Missing acl.ACLS constant in module {m_acl.__package__}')
return [
lib_acl.ACL(*elt)
for elt in getattr(m_acl, 'ACLS')
]
except AttributeError as exc:
logger.error(exc)
raise Exception(
f'Missing acl.ACLS constant in module {m_acl.__package__}') from exc
@staticmethod
def acls_route(domain, module_path=None, acl=None):
@ -118,7 +138,6 @@ class HalfDomain(Starlette):
[acl_name]: {
callable: fct_reference,
docs: fct_docstring,
result: fct_result
}
}
"""
@ -131,24 +150,84 @@ class HalfDomain(Starlette):
m_acl = HalfDomain.m_acl(module, acl)
for acl_name, doc, order in HalfDomain.acls(
module,
acl=acl):
fct = getattr(m_acl, acl_name)
d_res[acl_name] = {
for elt in HalfDomain.acls(module, acl=acl):
fct = getattr(m_acl, elt.name)
d_res[elt.name] = {
'callable': fct,
'docs': doc,
'result': None
'docs': elt.documentation
}
return d_res
# def schema(self):
@staticmethod
def acls_router(domain, module_path=None, acl=None):
""" Returns a Router object with the following routes :
/ : The "acls" field of the API metadatas
/{acl_name} : If the ACL is defined as public, a route that returns either status code 200 or 401 on HEAD/GET request
"""
routes = []
d_res = {}
module = importlib.import_module(domain) \
if module_path is None \
else importlib.import_module(module_path)
m_acl = HalfDomain.m_acl(module, acl)
for elt in HalfDomain.acls(module, acl=acl):
fct = getattr(m_acl, elt.name)
d_res[elt.name] = {
'callable': fct,
'docs': elt.documentation,
'public': elt.public
}
if elt.public:
try:
if inspect.iscoroutinefunction(fct):
logger.warning('async decorator are not yet supported')
else:
inner = fct()
if inspect.iscoroutinefunction(fct) or callable(inner):
fct = inner
except TypeError:
# Fct is not a decorator or is not well called (has no default arguments)
# We can ignore this
pass
routes.append(
AclRoute(f'/{elt.name}', fct, elt)
)
d_res_under_domain_name = {}
d_res_under_domain_name[HalfDomain.name(module)] = d_res
routes.append(
Route(
'/',
JSONRoute(d_res_under_domain_name),
methods=['GET']
)
)
return Router(routes)
@staticmethod
def gen_routes(m_router: ModuleType,
verb: str,
path: List[str],
params: List[Dict]) -> Tuple[FunctionType, Dict]:
params: List[Dict],
path_param_docstrings: Dict[str, str] = {}) -> Tuple[FunctionType, Dict]:
"""
Returns a tuple of the function associatied to the verb and path arguments,
and the dictionary of it's acls
@ -180,6 +259,13 @@ class HalfDomain(Starlette):
fct_name = get_fct_name(verb, path[-1])
if hasattr(m_router, fct_name):
fct = getattr(m_router, fct_name)
fct_docstring_obj = yaml.safe_load(fct.__doc__)
if 'parameters' not in fct_docstring_obj and path_param_docstrings:
fct_docstring_obj['parameters'] = list(map(
yaml.safe_load,
path_param_docstrings.values()))
fct.__doc__ = yaml.dump(fct_docstring_obj)
else:
raise UndefinedFunction('{}.{}'.format(m_router.__name__, fct_name or ''))
@ -188,11 +274,11 @@ class HalfDomain(Starlette):
return route_decorator(fct), params
# TODO: Remove when using only sync functions
return acl.args_check(fct), params
return lib_acl.args_check(fct), params
@staticmethod
def gen_router_routes(m_router, path: List[str]) -> \
def gen_router_routes(m_router, path: List[str], PATH_PARAMS={}) -> \
Iterator[Tuple[str, str, ModuleType, Coroutine, List]]:
"""
Recursive generator that parses a router (or a subrouter)
@ -220,17 +306,32 @@ class HalfDomain(Starlette):
yield ('/'.join(filter(lambda x: len(x) > 0, path)),
verb,
m_router,
*HalfDomain.gen_routes(m_router, verb, path, params[verb])
*HalfDomain.gen_routes(m_router, verb, path, params[verb], PATH_PARAMS)
)
for subroute in params.get('SUBROUTES', []):
#logger.debug('Processing subroute **%s** - %s', subroute, m_router.__name__)
subroute_module = importlib.import_module(f'.{subroute}', m_router.__name__)
param_match = re.fullmatch('^([A-Z_]+)_([a-z]+)$', subroute)
parameter_name = None
if param_match is not None:
try:
parameter_name = param_match.groups()[0].lower()
if parameter_name in PATH_PARAMS:
raise Exception(f'Duplicate parameter name in same path! {subroute} : {parameter_name}')
parameter_type = param_match.groups()[1]
path.append('{{{}:{}}}'.format(
param_match.groups()[0].lower(),
param_match.groups()[1]))
parameter_name,
parameter_type,
)
)
try:
PATH_PARAMS[parameter_name] = subroute_module.param_docstring
except AttributeError as exc:
PATH_PARAMS[parameter_name] = param_docstring_default(parameter_name, parameter_type)
except AssertionError as exc:
raise UnknownPathParameterType(subroute) from exc
else:
@ -238,14 +339,19 @@ class HalfDomain(Starlette):
try:
yield from HalfDomain.gen_router_routes(
importlib.import_module(f'.{subroute}', m_router.__name__),
path)
subroute_module,
path,
PATH_PARAMS
)
except ImportError as exc:
logger.error('Failed to import subroute **{%s}**', subroute)
raise exc
path.pop()
if parameter_name:
PATH_PARAMS.pop(parameter_name)
path.pop()
@ -317,8 +423,8 @@ class HalfDomain(Starlette):
Generator(HalfRoute)
"""
yield HalfRoute('/',
JSONRoute([ self.schema() ]),
[{'acl': acl.public}],
self.schema_openapi(),
[{'acl': lib_acl.public}],
'GET'
)
@ -371,3 +477,36 @@ class HalfDomain(Starlette):
}
schema['paths'] = self.schema_dict()
return schema
def schema_openapi(self) -> Route:
schema = SchemaGenerator(
{
'openapi': '3.0.0',
'info': {
'title': self.name,
'version': self.version,
'x-acls': tuple(getattr(self.m_acl, 'ACLS', ())),
**({
f'x-{key}': value
for key, value in self.d_domain.items()
}),
},
'components': self.schema_components
}
)
async def inner(request, *args, **kwargs):
"""
description: |
Returns the current API routes description (OpenAPI v3)
as a JSON object
responses:
200:
description: API Schema in OpenAPI v3 format
"""
return ORJSONResponse(
schema.get_schema(routes=request.app.routes))
return inner

View File

@ -9,6 +9,7 @@ It defines the following globals :
- application (the asgi application itself - a starlette object)
"""
import sys
import logging
import time
import importlib
@ -19,7 +20,7 @@ from starlette.applications import Starlette
from starlette.authentication import UnauthenticatedUser
from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.routing import Route, Mount
from starlette.routing import Router, Route, Mount
from starlette.requests import Request
from starlette.responses import Response, PlainTextResponse
from starlette.middleware.authentication import AuthenticationMiddleware
@ -44,14 +45,24 @@ from .half_domain import HalfDomain
from halfapi import __version__
class HalfAPI(Starlette):
def __init__(self, config,
def __init__(self,
config,
d_routes=None):
config_logging(logging.DEBUG)
# Set log level (defaults to debug)
config_logging(
getattr(logging, config.get('loglevel', 'DEBUG').upper(), 'DEBUG')
)
self.config = config
SECRET = self.config.get('secret')
PRODUCTION = self.config.get('production', True)
DRYRUN = self.config.get('dryrun', False)
TIMINGMIDDLEWARE = self.config.get('timingmiddleware', False)
if DRYRUN:
logger.info('HalfAPI starting in dry-run mode')
else:
logger.info('HalfAPI starting')
self.PRODUCTION = PRODUCTION
self.SECRET = SECRET
@ -65,7 +76,7 @@ class HalfAPI(Starlette):
Mount('/halfapi', routes=list(self.halfapi_routes()))
)
logger.info('Config: %s', self.config)
logger.debug('Config: %s', self.config)
domains = {
key: elt
@ -73,7 +84,7 @@ class HalfAPI(Starlette):
if elt.get('enabled', False)
}
logger.info('Active domains: %s', domains)
logger.debug('Active domains: %s', domains)
if d_routes:
# Mount the routes from the d_routes argument - domain-less mode
@ -99,8 +110,7 @@ class HalfAPI(Starlette):
500: gen_exception_route(HalfAPI.exception),
501: gen_exception_route(NotImplementedResponse),
503: gen_exception_route(ServiceUnavailableResponse)
},
on_startup=startup_fcts
}
)
schemas = []
@ -145,7 +155,7 @@ class HalfAPI(Starlette):
on_error=on_auth_error
)
if not PRODUCTION:
if not PRODUCTION and TIMINGMIDDLEWARE:
self.add_middleware(
TimingMiddleware,
client=HTimingClient(),
@ -158,6 +168,12 @@ class HalfAPI(Starlette):
return __version__
async def version_async(self, request, *args, **kwargs):
"""
description: Version route
responses:
200:
description: Currently running HalfAPI's version
"""
return Response(self.version)
@staticmethod
@ -174,11 +190,21 @@ class HalfAPI(Starlette):
"""
async def get_user(request, *args, **kwargs):
"""
description: WhoAmI route
responses:
200:
description: The currently logged-in user
content:
application/json:
schema:
type: object
"""
return ORJSONResponse({'user':request.user})
yield Route('/whoami', get_user)
yield Route('/schema', schema_json)
yield Route('/acls', self.acls_route())
yield Mount('/acls', self.acls_router())
yield Route('/version', self.version_async)
""" Halfapi debug routes definition
"""
@ -220,35 +246,26 @@ class HalfAPI(Starlette):
time.sleep(1)
sys.exit(0)
def acls_route(self):
module = None
res = {
domain: HalfDomain.acls_route(
domain,
module_path=domain_conf.get('module'),
acl=domain_conf.get('acl'))
for domain, domain_conf in self.config.get('domain', {}).items()
if isinstance(domain_conf, dict) and domain_conf.get('enabled', False)
}
def acls_router(self):
mounts = {}
async def wrapped(req, *args, **kwargs):
for domain, domain_acls in res.items():
for acl_name, d_acl in domain_acls.items():
fct = d_acl['callable']
if not callable(fct):
raise Exception(
'No callable function in acl definition %s',
acl_name)
for domain, domain_conf in self.config.get('domain', {}).items():
if isinstance(domain_conf, dict) and domain_conf.get('enabled', False):
mounts['domain'] = HalfDomain.acls_router(
domain,
module_path=domain_conf.get('module'),
acl=domain_conf.get('acl')
)
fct_result = fct(req, *args, **kwargs)
if callable(fct_result):
fct_result = fct()(req, *args, **kwargs)
d_acl['result'] = fct_result
return ORJSONResponse(res)
return wrapped
if len(mounts) > 1:
return Router([
Mount(f'/{domain}', acls_router)
for domain, acls_router in mounts.items()
])
elif len(mounts) == 1:
return Mount('/', mounts.popitem()[1])
else:
return Router()
@property
def domains(self):
@ -288,3 +305,12 @@ class HalfAPI(Starlette):
self.mount(kwargs.get('path', name), self.__domains[name])
return self.__domains[name]
def __main__():
return HalfAPI(CONFIG).application
if __name__ == '__main__':
__main__()

View File

@ -2,10 +2,14 @@
"""
Base ACL module that contains generic functions for domains ACL
"""
from dataclasses import dataclass
from functools import wraps
from json import JSONDecodeError
import yaml
from starlette.authentication import UnauthenticatedUser
from starlette.exceptions import HTTPException
from starlette.routing import Route
from starlette.responses import Response
from ..logging import logger
@ -118,7 +122,57 @@ def args_check(fct):
# ACLS list for doc and priorities
# Write your own constant in your domain or import this one
# Format : (acl_name: str, acl_documentation: str, priority: int, [public=False])
#
# The 'priority' integer is greater than zero and the lower values means more
# priority. For a route, the order of declaration of the ACLs should respect
# their priority.
#
# When the 'public' boolean value is True, a route protected by this ACL is
# defined on the "/halfapi/acls/acl_name", that returns an empty response and
# the status code 200 or 401.
ACLS = (
('private', public.__doc__, 0),
('public', public.__doc__, 999)
('private', private.__doc__, 0, True),
('public', public.__doc__, 999, True)
)
@dataclass
class ACL():
name: str
documentation: str
priority: int
public: bool = False
class AclRoute(Route):
def __init__(self, path, acl_fct, acl: ACL):
self.acl_fct = acl_fct
self.name = acl.name
self.description = acl.documentation
self.docstring = yaml.dump({
'description': f'{self.name}: {self.description}',
'responses': {
'200': {
'description': 'ACL OK'
},
'401': {
'description': 'ACL FAIL'
}
}
})
async def endpoint(request, *args, **kwargs):
if request.method == 'GET':
logger.warning('Deprecated since 0.6.28, use HEAD method since now')
if self.acl_fct(request, *args, **kwargs) is True:
return Response(status_code=200)
return Response(status_code=401)
endpoint.__doc__ = self.docstring
return super().__init__(path, methods=['HEAD', 'GET'], endpoint=endpoint)

View File

@ -44,7 +44,7 @@ DOMAIN_SCHEMA = Schema({
Optional('version'): str,
Optional('patch_release'): str,
Optional('acls'): [
[str, str, int]
[str, str, int, Optional(bool)]
]
})

View File

@ -17,7 +17,7 @@ class DomainMiddleware(BaseHTTPMiddleware):
- acl
"""
def __init__(self, app, domain):
def __init__(self, app, domain=None):
""" app: HalfAPI instance
"""
logger.info('DomainMiddleware app:%s domain:%s', app, domain)

View File

@ -56,10 +56,8 @@ def parse_query(q_string: str = ""):
>>> parse_query('limit:10')
<function parse_query.<locals>.select at 0x...>
>>> parse_query('limit=10')
Traceback (most recent call last):
...
starlette.exceptions.HTTPException: 400
# >>> parse_query('limit=10')
# starlette.exceptions.HTTPException: 400
"""

View File

@ -13,6 +13,7 @@ import os
import importlib
from typing import Dict, Coroutine, List
from types import ModuleType
import yaml
from starlette.schemas import SchemaGenerator
@ -27,8 +28,12 @@ SCHEMAS = SchemaGenerator(
async def schema_json(request, *args, **kwargs):
"""
description: Returns the current API routes description (OpenAPI v3)
as a JSON object
description: |
Returns the current API routes description (OpenAPI v3)
as a JSON object
responses:
200:
description: API Schema in OpenAPI v3 format
"""
return ORJSONResponse(
SCHEMAS.get_schema(routes=request.app.routes))
@ -110,3 +115,23 @@ def schema_csv_dict(csv: List[str], prefix='/') -> Dict:
})
return schema_d
def param_docstring_default(name, type):
""" Returns a default docstring in OpenAPI format for a path parameter
"""
type_map = {
'str': 'string',
'uuid': 'string',
'path': 'string',
'int': 'number',
'float': 'number'
}
return yaml.dump({
'name': name,
'in': 'path',
'description': f'default description for path parameter {name}',
'required': True,
'schema': {
'type': type_map[type]
}
})

View File

@ -1,8 +1,10 @@
import logging
default_level = logging.DEBUG
default_format = '%(asctime)s [%(process)d] [%(levelname)s] %(message)s'
default_datefmt = '[%Y-%m-%d %H:%M:%S %z]'
def config_logging(level=logging.INFO):
def config_logging(level=default_level, format=default_format, datefmt=default_datefmt):
# When run by 'uvicorn ...', a root handler is already
# configured and the basicConfig below does nothing.
# To get the desired formatting:
@ -12,8 +14,8 @@ def config_logging(level=logging.INFO):
# https://github.com/encode/uvicorn/issues/511
logging.basicConfig(
# match gunicorn format
format='%(asctime)s [%(process)d] [%(levelname)s] %(message)s',
datefmt='[%Y-%m-%d %H:%M:%S %z]',
format=format,
datefmt=datefmt,
level=level)
# When run by 'gunicorn -k uvicorn.workers.UvicornWorker ...',
@ -27,5 +29,4 @@ def config_logging(level=logging.INFO):
logging.getLogger('uvicorn.access').propagate = True
logging.getLogger('uvicorn.error').propagate = True
config_logging()
logger = logging.getLogger()

View File

@ -4,12 +4,14 @@ import os
import sys
import json
from json.decoder import JSONDecodeError
import toml
from unittest import TestCase
from starlette.testclient import TestClient
from click.testing import CliRunner
from ..cli.cli import cli
from ..halfapi import HalfAPI
from ..half_domain import HalfDomain
from ..conf import DEFAULT_CONF
from pprint import pprint
import tempfile
@ -61,6 +63,7 @@ class TestDomain(TestCase):
self.runner = class_(mix_stderr=False)
# HTTP
# Fake default values of default configuration
self.halfapi_conf = {
'secret': 'testsecret',
'production': False,
@ -79,7 +82,7 @@ class TestDomain(TestCase):
_, self.config_file = tempfile.mkstemp()
with open(self.config_file, 'w') as fh:
fh.write(json.dumps(self.halfapi_conf))
fh.write(toml.dumps(self.halfapi_conf))
self.halfapi = HalfAPI(self.halfapi_conf)
@ -122,26 +125,28 @@ class TestDomain(TestCase):
def check_routes(self):
r = self.client.request('get', '/')
assert r.status_code == 200
schemas = r.json()
assert isinstance(schemas, list)
for schema in schemas:
assert isinstance(schema, dict)
assert 'openapi' in schema
assert 'info' in schema
assert 'paths' in schema
assert 'domain' in schema
schema = r.json()
assert isinstance(schema, dict)
assert 'openapi' in schema
assert 'info' in schema
assert 'paths' in schema
r = self.client.request('get', '/halfapi/acls')
"""
assert r.status_code == 200
d_r = r.json()
assert isinstance(d_r, dict)
assert self.domain_name in d_r.keys()
ACLS = HalfDomain.acls(self.module, self.acl_path)
assert len(ACLS) == len(d_r[self.domain_name])
for acl_name in ACLS:
assert acl_name[0] in d_r[self.domain_name]
"""
for acl_rule in ACLS:
assert len(acl_rule.name) > 0
assert acl_rule.name in d_r[self.domain_name]
assert len(acl_rule.documentation) > 0
assert isinstance(acl_rule.priority, int)
assert acl_rule.priority >= 0
if acl_rule.public is True:
r = self.client.request('get', f'/halfapi/acls/{acl_rule.name}')
assert r.status_code in [200, 401]

View File

@ -1,5 +1,5 @@
[pytest]
testpaths = tests
testpaths = tests halfapi
addopts = --doctest-modules
doctest_optionflags = ELLIPSIS
doctest_optionflags = ELLIPSIS IGNORE_EXCEPTION_DETAIL
pythonpath = ./tests

View File

@ -44,7 +44,7 @@ setup(
python_requires=">=3.8",
install_requires=[
"PyJWT>=2.6.0,<2.7.0",
"starlette>=0.23,<0.24",
"starlette>=0.33,<0.34",
"click>=8,<9",
"uvicorn>=0.13,<1",
"orjson>=3.8.5,<4",
@ -71,7 +71,10 @@ setup(
"pytest-asyncio",
"pylint",
"requests",
"httpx"
"httpx",
"openapi-schema-validator",
"openapi-spec-validator",
"coverage"
],
"pyexcel":[
"pyexcel",

View File

@ -5,10 +5,12 @@ import importlib
import tempfile
from unittest.mock import patch
import json
import toml
import pytest
from click.testing import CliRunner
from configparser import ConfigParser
from halfapi.conf import DEFAULT_CONF, PROJECT_LEVEL_KEYS, DOMAIN_LEVEL_KEYS
PROJNAME = os.environ.get('PROJ','tmp_api')
@ -23,22 +25,50 @@ class TestCliProj():
def test_domain_commands(self, project_runner):
""" TODO: Test create command
"""
test_conf = {
'project': {
'port': '3010',
'loglevel': 'warning'
},
'domain': {
'dummy_domain': {
'port': 4242,
'name': 'dummy_domain',
'enabled': True
}
}
}
r = project_runner('domain')
print(r.stdout)
assert r.exit_code == 1
_, tmp_conf = tempfile.mkstemp()
with open(tmp_conf, 'w') as fh:
fh.write(
json.dumps({
'domain': {
'dummy_domain': {
'name': 'dummy_domain',
'enabled': True
}
}
})
toml.dumps(test_conf)
)
r = project_runner(f'domain dummy_domain --conftest {tmp_conf}')
assert r.exit_code == 0
r_conf = toml.loads(r.stdout)
for key, value in r_conf.items():
if key == 'domain':
continue
assert key in PROJECT_LEVEL_KEYS
if key == 'port':
assert value == test_conf['domain']['dummy_domain']['port']
elif key == 'loglevel':
assert value == test_conf['project']['loglevel']
else:
assert value == DEFAULT_CONF[key.upper()]
assert json.dumps(test_conf['domain']) == json.dumps(r_conf['domain'])
for key in test_conf['domain']['dummy_domain'].keys():
assert key in DOMAIN_LEVEL_KEYS
# Default command "run"
r = project_runner(f'domain dummy_domain --dry-run {tmp_conf}')
print(r.stdout)
assert r.exit_code == 0

View File

@ -6,7 +6,22 @@ domain = {
'id': '8b88e60a625369235b36c2d6d70756a0c02c1c7fb169fcee6dc820bcf9723f5a',
'deps': (
('halfapi', '=={}'.format(halfapi_version)),
)
),
'schema_components': {
'schemas': {
'Pinnochio': {
'type': 'object',
'required': {
'id',
'name',
'nose_size'
},
'properties': {
'id': {'type': 'string'},
'name': {'type': 'string'},
'nose_size': {'type': 'number'}
}
}
}
}
}

View File

@ -1,5 +1,5 @@
from halfapi.lib import acl
from halfapi.lib.acl import public, private
from halfapi.lib.acl import public, private, ACLS
from random import randint
def random(*args):
@ -8,7 +8,6 @@ def random(*args):
return randint(0,1) == 1
ACLS = (
('public', public.__doc__, 999),
('random', random.__doc__, 10),
('private', private.__doc__, 0)
*ACLS,
('random', random.__doc__, 10)
)

View File

@ -12,6 +12,9 @@ async def get(test):
"""
description:
returns the path parameter
responses:
200:
description: test response
"""
return ORJSONResponse(str(test))
@ -19,6 +22,9 @@ def post(test):
"""
description:
returns the path parameter
responses:
200:
description: test response
"""
return str(test)
@ -26,6 +32,9 @@ def patch(test):
"""
description:
returns the path parameter
responses:
200:
description: test response
"""
return str(test)
@ -33,6 +42,9 @@ def put(test):
"""
description:
returns the path parameter
responses:
200:
description: test response
"""
return str(test)
@ -40,5 +52,8 @@ def delete(test):
"""
description:
returns the path parameter
responses:
200:
description: test response
"""
return str(test)

View File

@ -1,10 +1,21 @@
from uuid import uuid4
from halfapi.lib import acl
ACLS = {
'GET' : [{'acl':acl.public}]
}
def get():
"""
description:
Not implemented
description: The pinnochio guy
responses:
200:
description: test response
content:
application/json:
schema:
$ref: "#/components/schemas/Pinnochio"
"""
raise NotImplementedError
return {
'id': str(uuid4()),
'name': 'pinnochio',
'nose_size': 42
}

View File

@ -60,6 +60,9 @@ def get(data):
"""
description:
returns the arguments passed in
responses:
200:
description: test response
"""
logger.error('%s', data['foo'])
return data
@ -68,6 +71,9 @@ def post(data):
"""
description:
returns the arguments passed in
responses:
200:
description: test response
"""
logger.error('%s', data)
return data

View File

@ -25,24 +25,43 @@ ROUTES = {
async def get_abc_alphabet_TEST(request, *args, **kwargs):
"""
description: Not implemented
responses:
200:
description: test response
parameters:
- name: test
in: path
description: Test parameter in route with "ROUTES" constant
required: true
schema:
type: string
"""
return NotImplementedResponse()
async def get_abc_pinnochio(request, *args, **kwargs):
"""
description: Not implemented
responses:
200:
description: test response
"""
return NotImplementedResponse()
async def get_config(request, *args, **kwargs):
"""
description: Not implemented
responses:
200:
description: test response
"""
return NotImplementedResponse()
async def get_arguments(request, *args, **kwargs):
"""
description: Liste des datatypes.
responses:
200:
description: test response
"""
return ORJSONResponse({
'foo': kwargs.get('data').get('foo'),

View File

@ -12,6 +12,9 @@ def get(halfapi):
"""
description:
returns the configuration of the domain
responses:
200:
description: test response
"""
logger.error('%s', halfapi)
# TODO: Remove in 0.7.0

View File

@ -0,0 +1,8 @@
param_docstring = """
name: second
in: path
description: second parameter description test
required: true
schema:
type: string
"""

View File

@ -0,0 +1,20 @@
from uuid import UUID
from halfapi.lib import acl
ACLS = {
'GET': [{'acl': acl.public}]
}
def get(first, second, third):
"""
description: a Test route for path parameters
responses:
200:
description: The test passed!
500:
description: The test did not pass :(
"""
assert isintance(first, str)
assert isintance(second, UUID)
assert isintance(third, int)
return ''

View File

@ -7,6 +7,10 @@ import json
import os
import sys
import pprint
import openapi_spec_validator
import logging
logger = logging.getLogger()
from halfapi.lib.constants import API_SCHEMA
@ -58,8 +62,6 @@ def test_schema(application_debug):
c = TestClient(application_debug)
r = c.request('get', '/')
schemas = r.json()
assert isinstance(schemas, list)
for schema in schemas:
assert isinstance(schema, dict)
assert API_SCHEMA.validate(schema)
schema = r.json()
assert isinstance(schema, dict)
openapi_spec_validator.validate_spec(schema)

View File

@ -1,6 +1,8 @@
import pytest
from halfapi.testing.test_domain import TestDomain
from pprint import pprint
import logging
logger = logging.getLogger()
class TestDummyDomain(TestDomain):
from .dummy_domain import domain
@ -77,3 +79,28 @@ class TestDummyDomain(TestDomain):
res = self.client.request('post', '/arguments', json={ **arg_dict, 'z': True})
assert res.json() == {**arg_dict, 'z': True}
def test_schema_path_params(self):
res = self.client.request('get', '/halfapi/schema')
schema = res.json()
logger.debug(schema)
assert len(schema['paths']) > 0
route = schema['paths']['/path_params/{first}/one/{second}/two/{third}']
assert 'parameters' in route['get']
parameters = route['get']['parameters']
assert len(parameters) == 3
param_map = {
elt['name']: elt
for elt in parameters
}
assert param_map['second']['description'] == 'second parameter description test'

View File

@ -1,4 +1,5 @@
import importlib
from halfapi.testing.test_domain import TestDomain
def test_dummy_domain():
from . import dummy_domain

View File

@ -21,8 +21,8 @@ def test_call(application_debug):
assert r.status_code == 400
assert r.headers['x-domain'] == 'dummy_domain'
assert r.headers['x-acl'] == 'public'
assert 'foo' in r.headers['x-args-required']
assert 'bar' in r.headers['x-args-required']
assert 'foo' in r.headers['x-args-required'].split(',')
assert 'bar' in r.headers['x-args-required'].split(',')
assert r.headers['x-args-optional'] == 'x'
c = TestClient(application_debug)
@ -30,8 +30,9 @@ def test_call(application_debug):
assert r.status_code == 400
assert r.headers['x-domain'] == 'dummy_domain'
assert r.headers['x-acl'] == 'public'
assert 'foo' in r.headers['x-args-required']
assert 'baz' in r.headers['x-args-required']
assert r.headers['x-args-optional'] == 'truebidoo'
assert 'foo' in r.headers['x-args-required'].split(',')
assert 'baz' in r.headers['x-args-required'].split(',')
assert 'truebidoo' in r.headers['x-args-optional'].split(',')
assert 'z' in r.headers['x-args-optional'].split(',')