major refactoring

tests/api/conftest.py

@@ -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

tests/api/test_common.py

@@ -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

tests/api/test_requests.py

@@ -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