delta-barth/delta-barth-py
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects 3 Releases 3 Wiki Activity

major refactoring

Browse Source
This commit is contained in:
Florian Förster
2025-03-07 12:23:59 +01:00
parent a94fd4a936
commit 76f58ecba0
13 changed files with 526 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
tests/api/conftest.py Normal file
View File

@@ -0,0 +1,18 @@
import pytest
from delta_barth.api import common
from delta_barth.constants import HTTP_BASE_CONTENT_HEADERS
@pytest.fixture(scope="function")
def session(credentials, api_base_url) -> common.Session:
session = common.Session(HTTP_BASE_CONTENT_HEADERS)
session.set_base_url(api_base_url)
session.set_credentials(
user_name=credentials["user"],
password=credentials["pwd"],
database=credentials["db"],
mandant=credentials["mandant"],
)
return session

190
tests/api/test_common.py
View File

@@ -1,18 +1,13 @@
from datetime import datetime as Datetime
import pytest
from pydantic import ValidationError
from delta_barth._management import CURRENT_SESSION
from delta_barth.api import common
from delta_barth.constants import DEFAULT_API_ERR_CODE
from delta_barth.constants import DEFAULT_API_ERR_CODE, HTTP_BASE_CONTENT_HEADERS
from delta_barth.errors import (
ApiConnectionError,
UnspecifiedRequestType,
)
from delta_barth.types import HttpRequestTypes
"http://test.com/ "
@pytest.mark.parametrize(
["case", "expect"],
@@ -50,9 +45,42 @@ def test_combine_route(base, route, expect):
assert res == expect
def test_assert_login():
with pytest.raises(ApiConnectionError):
common._assert_login_status()
def test_validate_creds(credentials):
creds = common.validate_credentials(
user_name=credentials["user"],
password=credentials["pwd"],
database=credentials["db"],
mandant=credentials["mandant"],
)
assert creds.user_name == credentials["user"]
assert creds.password == credentials["pwd"]
assert creds.database == credentials["db"]
assert creds.mandant == credentials["mandant"]
# with whitespaces
user = " " + credentials["user"] + " "
creds = common.validate_credentials(
user_name=user,
password=credentials["pwd"],
database=credentials["db"],
mandant=credentials["mandant"],
)
assert user != credentials["user"]
assert creds.user_name == credentials["user"]
# invalid type
user = 123
with pytest.raises(ValidationError):
creds = common.validate_credentials(
user_name=user, # type: ignore
password=credentials["pwd"],
database=credentials["db"],
mandant=credentials["mandant"],
)
# TODO removal
# def test_assert_login():
# with pytest.raises(ApiConnectionError):
# common._assert_login_status()
@pytest.mark.api_con_required
@@ -68,89 +96,87 @@ def test_ping(api_base_url):
resp = common.ping(api_base_url, HttpRequestTypes.POST)
@pytest.mark.api_con_required
def test_login_logout(credentials, api_base_url):
assert CURRENT_SESSION.session_token is None
resp, state = common.login(
base_url=api_base_url,
def test_session(credentials, api_base_url):
session = common.Session(HTTP_BASE_CONTENT_HEADERS)
assert session.session_token is None
assert session._creds is None
assert session._base_url is None
session.set_base_url(api_base_url)
assert session._base_url is not None
session.set_credentials(
user_name=credentials["user"],
password=credentials["pwd"],
database=credentials["db"],
mandant=credentials["mandant"],
)
assert state.code == 0
assert CURRENT_SESSION.session_token is not None
resp, state = common.logout(
base_url=api_base_url,
)
assert resp is None
assert state.code == 0
assert CURRENT_SESSION.session_token is None
assert "DelecoToken" not in CURRENT_SESSION.headers
assert session._creds is not None
resp, state = common.login(
base_url=api_base_url,
assert session.session_token is None
assert not session.logged_in
@pytest.mark.api_con_required
def test_login_logout(session, credentials):
assert not session.logged_in
resp, status = session.login()
assert resp is not None
assert status.code == 0
assert session.session_token is not None
resp, status = session.logout()
assert resp is None
assert status.code == 0
assert session.session_token is None
assert "DelecoToken" not in session.headers
session.set_credentials(
user_name=credentials["user"],
password="WRONG_PASSWORD",
database=credentials["db"],
mandant=credentials["mandant"],
)
resp, status = session.login()
assert resp is not None
assert state.code == DEFAULT_API_ERR_CODE
assert state.api_server_error is not None
assert state.api_server_error.status_code == 409
assert state.api_server_error.message == "Nutzer oder Passwort falsch."
assert status.code == DEFAULT_API_ERR_CODE
assert status.api_server_error is not None
assert status.api_server_error.status_code == 409
assert status.api_server_error.message == "Nutzer oder Passwort falsch."
@pytest.mark.api_con_required
def test_get_sales_prognosis_data(credentials, api_base_url):
resp, state = common.login(
base_url=api_base_url,
user_name=credentials["user"],
password=credentials["pwd"],
database=credentials["db"],
mandant=credentials["mandant"],
)
# test without company ID
assert state.code == 0
date = Datetime(2022, 6, 1)
resp, state = common.get_sales_prognosis_data(api_base_url, None, date)
assert state.code == 0
assert len(resp.daten) > 0
date = Datetime(2030, 1, 1)
resp, state = common.get_sales_prognosis_data(api_base_url, None, date)
assert state.code == 0
assert len(resp.daten) == 0
# test with company ID
assert state.code == 0
date = Datetime(2022, 6, 1)
company_id = 1024
resp, state = common.get_sales_prognosis_data(api_base_url, company_id, date)
assert state.code == 0
assert len(resp.daten) > 0
date = Datetime(2030, 1, 1)
resp, state = common.get_sales_prognosis_data(api_base_url, company_id, date)
assert state.code == 0
assert len(resp.daten) == 0
# test with non-existent company ID
assert state.code == 0
date = Datetime(2022, 6, 1)
company_id = 1000024
resp, state = common.get_sales_prognosis_data(api_base_url, company_id, date)
# TODO check if this behaviour is still considered "successful"
assert state.code == 0
assert len(resp.daten) == 0
# test without date
company_id = 1024
resp, state = common.get_sales_prognosis_data(api_base_url, company_id, None)
assert state.code == 0
assert len(resp.daten) > 0
# test without filters
resp, state = common.get_sales_prognosis_data(api_base_url, None, None)
assert state.code == 0
assert len(resp.daten) > 0
# close connection
resp, state = common.logout(
base_url=api_base_url,
)
assert state.code == 0
def test_assert_login_while_logged_out(session):
assert session.session_token is None
assert session._creds is not None
# test logged out state
resp, status = session.assert_login()
assert resp is not None
assert status.code == 0
assert session.session_token is not None
resp, status = session.logout()
assert status.code == 0
# test already logged in
assert session.session_token is None
assert session._creds is not None
_, status = session.login()
assert status.code == 0
resp, status = session.assert_login()
assert resp is not None
assert status.code == 0
assert session.session_token is not None
resp, status = session.logout()
assert status.code == 0
# test invalid token
assert session.session_token is None
assert session._creds is not None
_, status = session.login()
assert status.code == 0
session._session_token = "WRONGTOKEN"
resp, status = session.assert_login()
assert resp is not None
assert status.code == 0
assert session.session_token is not None
resp, status = session.logout()
assert status.code == 0

51
tests/api/test_requests.py Normal file
View File

@@ -0,0 +1,51 @@
from datetime import datetime as Datetime
import pytest
from delta_barth.api import requests as requests_
@pytest.mark.api_con_required
def test_get_sales_prognosis_data(session):
resp, state = session.login()
# test without company ID
assert state.code == 0
date = Datetime(2022, 6, 1)
resp, state = requests_.get_sales_prognosis_data(session, None, date)
assert state.code == 0
assert len(resp.daten) > 0
date = Datetime(2030, 1, 1)
resp, state = requests_.get_sales_prognosis_data(session, None, date)
assert state.code == 0
assert len(resp.daten) == 0
# test with company ID
assert state.code == 0
date = Datetime(2022, 6, 1)
company_id = 1024
resp, state = requests_.get_sales_prognosis_data(session, company_id, date)
assert state.code == 0
assert len(resp.daten) > 0
date = Datetime(2030, 1, 1)
resp, state = requests_.get_sales_prognosis_data(session, company_id, date)
assert state.code == 0
assert len(resp.daten) == 0
# test with non-existent company ID
assert state.code == 0
date = Datetime(2022, 6, 1)
company_id = 1000024
resp, state = requests_.get_sales_prognosis_data(session, company_id, date)
# TODO check if this behaviour is still considered "successful"
assert state.code == 0
assert len(resp.daten) == 0
# test without date
company_id = 1024
resp, state = requests_.get_sales_prognosis_data(session, company_id, None)
assert state.code == 0
assert len(resp.daten) > 0
# test without filters
resp, state = requests_.get_sales_prognosis_data(session, None, None)
assert state.code == 0
assert len(resp.daten) > 0
# close connection
resp, state = session.logout()
assert state.code == 0

2
tests/conftest.py
View File

@@ -9,7 +9,7 @@ import pandas as pd
import pytest
if TYPE_CHECKING:
from delta_barth.api.common import SalesPrognosisResponse
from delta_barth.api.requests import SalesPrognosisResponse
@pytest.fixture(scope="session")

53
tests/test_errors.py
View File

@@ -4,20 +4,20 @@ from dataclasses import asdict
from typing import cast
import pytest
from pydantic import ValidationError
import delta_barth._management
from delta_barth import errors
from delta_barth.constants import DEFAULT_API_ERR_CODE
from delta_barth.types import DelBarApiError, Status
def test_state_handler_parsing():
def test_status_handler_parsing():
predef_errs = errors.DATA_PIPELINE_STATUS_DESCR
state_hdlr = delta_barth._management.StateHandler()
assert state_hdlr.pipe_states is not None
parsed_pipe_states = state_hdlr.pipe_states
assert parsed_pipe_states.SUCCESS == state_hdlr.SUCCESS
status_hdlr = errors.StatusHandler()
assert status_hdlr.pipe_states is not None
parsed_pipe_states = status_hdlr.pipe_states
assert parsed_pipe_states.SUCCESS == status_hdlr.SUCCESS
parsed_pipe_states = asdict(parsed_pipe_states)
for err in predef_errs:
@@ -27,16 +27,16 @@ def test_state_handler_parsing():
assert dopt_err.description == err[2]
assert dopt_err.message == ""
state_hdlr._parse_data_pipe_states()
status_hdlr._parse_data_pipe_states()
def test_state_handler_internal():
def test_status_handler_internal():
DESCRIPTION = "test case"
MESSAGE = "an error occurred"
ERR_CODE = 101
state_hdlr = delta_barth._management.StateHandler()
new_err = state_hdlr.error(
status_hdlr = errors.StatusHandler()
new_err = status_hdlr.error(
description=DESCRIPTION,
message=MESSAGE,
code=ERR_CODE,
@@ -47,28 +47,28 @@ def test_state_handler_internal():
# failure cases
err_code = 50 # default lower bound: 100
with pytest.raises(ValueError):
new_err = state_hdlr.error(
new_err = status_hdlr.error(
description=DESCRIPTION,
message=MESSAGE,
code=err_code,
)
err_code = 500 # default upper bound: 400
with pytest.raises(ValueError):
new_err = state_hdlr.error(
new_err = status_hdlr.error(
description=DESCRIPTION,
message=MESSAGE,
code=err_code,
)
def test_state_handler_api_error():
def test_status_handler_api_error():
MESSAGE = "an error occurred"
api_err = DelBarApiError(status_code=401, message="test case")
assert api_err.status_code == 401
assert api_err.message == "test case"
state_hdlr = delta_barth._management.StateHandler()
new_err = state_hdlr.api_error(error=api_err)
status_hdlr = errors.StatusHandler()
new_err = status_hdlr.api_error(error=api_err)
assert new_err.code == DEFAULT_API_ERR_CODE
assert "API-Server" in new_err.description
assert new_err.message != MESSAGE
@@ -76,19 +76,18 @@ def test_state_handler_api_error():
assert new_err.api_server_error == api_err
@pytest.mark.new
def test_state_handler_raising():
state_hdlr = delta_barth._management.StateHandler()
def test_status_handler_raising():
status_hdlr = errors.StatusHandler()
# success: should not raise
err_state = state_hdlr.SUCCESS
assert state_hdlr.unwrap(err_state) is None
err_status = status_hdlr.SUCCESS
assert status_hdlr.unwrap(err_status) is None
# data related errors (predefined)
err_state = state_hdlr.pipe_states.BAD_QUALITY
err_descr = err_state.description
err_status = status_hdlr.pipe_states.BAD_QUALITY
err_descr = err_status.description
with pytest.raises(errors.UDataProcessingError):
try:
state_hdlr.unwrap(err_state)
status_hdlr.unwrap(err_status)
except errors.UDataProcessingError as err:
descr = str(err)
assert err_descr in descr
@@ -97,14 +96,14 @@ def test_state_handler_raising():
description = "test case"
message = "an error occurred"
err_code = 101
err_state = state_hdlr.error(
err_status = status_hdlr.error(
description=description,
message=message,
code=err_code,
)
with pytest.raises(errors.UInternalError):
try:
state_hdlr.unwrap(err_state)
status_hdlr.unwrap(err_status)
except errors.UInternalError as err:
descr = str(err)
assert description in descr
@@ -113,10 +112,10 @@ def test_state_handler_raising():
api_err = DelBarApiError(status_code=401, message="test case", code="1234")
description = "Kommunikation mit dem API-Server aufgetreten"
msg = "Bitte beachten Sie die"
err_state = state_hdlr.api_error(error=api_err)
err_status = status_hdlr.api_error(error=api_err)
with pytest.raises(errors.UApiError):
try:
state_hdlr.unwrap(err_state)
status_hdlr.unwrap(err_status)
except errors.UApiError as err:
descr = str(err)
assert description in descr