bump version to 0.5.12

pdm.lock

@@ -5,7 +5,7 @@
 groups = ["default", "dev", "lint", "nb", "tests"]
 strategy = ["inherit_metadata"]
 lock_version = "4.5.0"
-content_hash = "sha256:c3fd178d5c4736852fff59e2e4c5e3565b0fb80bf29ec5979e1e9c78d452ee1f"
+content_hash = "sha256:f2a2abd891603796228b21bfeb7a00fd998964fe9303a9e4e5971f63925261e8"
 
 [[metadata.targets]]
 requires_python = ">=3.11"
@@ -591,6 +591,17 @@ files = [
     {file = "dopt_basics-0.1.3.tar.gz", hash = "sha256:22ba30cbd385cb8929cb6a13fe01e253cd7d9617ef637e41609f2468691450e8"},
 ]
 
+[[package]]
+name = "et-xmlfile"
+version = "2.0.0"
+requires_python = ">=3.8"
+summary = "An implementation of lxml.xmlfile for the standard library"
+groups = ["dev"]
+files = [
+    {file = "et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa"},
+    {file = "et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54"},
+]
+
 [[package]]
 name = "execnet"
 version = "2.1.1"
@@ -1450,6 +1461,20 @@ files = [
     {file = "nvidia_nccl_cu12-2.25.1-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:362aed5963fb9ea2ed2f264409baae30143498fd0e5c503aeaa1badd88cdc54a"},
 ]
 
+[[package]]
+name = "openpyxl"
+version = "3.1.5"
+requires_python = ">=3.8"
+summary = "A Python library to read/write Excel 2010 xlsx/xlsm files"
+groups = ["dev"]
+dependencies = [
+    "et-xmlfile",
+]
+files = [
+    {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"},
+    {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"},
+]
+
 [[package]]
 name = "overrides"
 version = "7.7.0"
@@ -1571,6 +1596,31 @@ files = [
     {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"},
 ]
 
+[[package]]
+name = "pip"
+version = "25.1.1"
+requires_python = ">=3.9"
+summary = "The PyPA recommended tool for installing Python packages."
+groups = ["default"]
+files = [
+    {file = "pip-25.1.1-py3-none-any.whl", hash = "sha256:2913a38a2abf4ea6b64ab507bd9e967f3b53dc1ede74b01b0931e1ce548751af"},
+    {file = "pip-25.1.1.tar.gz", hash = "sha256:3de45d411d308d5054c2168185d8da7f9a2cd753dbac8acbfa88a8909ecd9077"},
+]
+
+[[package]]
+name = "pip-system-certs"
+version = "5.2"
+requires_python = ">=3.10"
+summary = "Automatically configures Python to use system certificates via truststore"
+groups = ["default"]
+dependencies = [
+    "pip>=24.2",
+]
+files = [
+    {file = "pip_system_certs-5.2-py3-none-any.whl", hash = "sha256:e6ef3e106d4d02313e33955c2bcc4c2b143b2da07ef91e28a6805a0c1c512126"},
+    {file = "pip_system_certs-5.2.tar.gz", hash = "sha256:80b776b5cf17191bf99d313699b7fce2fdb84eb7bbb225fd134109a82706406f"},
+]
+
 [[package]]
 name = "platformdirs"
 version = "4.3.6"

pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "delta-barth"
-version = "0.5.8"
+version = "0.5.12"
 description = "workflows and pipelines for the Python-based Plugin of Delta Barth's ERP system"
 authors = [
     {name = "Florian Förster", email = "f.foerster@d-opt.com"},
 ]
-dependencies = ["scikit-learn>=1.6.1", "pandas>=2.2.3", "xgboost>=2.1.4", "joblib>=1.4.2", "typing-extensions>=4.12.2", "requests>=2.32.3", "pydantic>=2.10.6", "dopt-basics>=0.1.3", "SQLAlchemy>=2.0.39", "psutil>=7.0.0"]
+dependencies = ["scikit-learn>=1.6.1", "pandas>=2.2.3", "xgboost>=2.1.4", "joblib>=1.4.2", "typing-extensions>=4.12.2", "requests>=2.32.3", "pydantic>=2.10.6", "dopt-basics>=0.1.3", "SQLAlchemy>=2.0.39", "psutil>=7.0.0", "pip-system-certs>=5.2"]
 requires-python = ">=3.11"
 readme = "README.md"
 license = {text = "LicenseRef-Proprietary"}
@@ -74,7 +74,7 @@ directory = "reports/coverage"
 
 
 [tool.bumpversion]
-current_version = "0.5.8"
+current_version = "0.5.12"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.
@@ -147,6 +147,7 @@ dev = [
     "bump-my-version>=1.1.1",
     "nox>=2025.2.9",
     "tomli-w>=1.2.0",
+    "openpyxl>=3.1.5",
 ]
 nb = [
     "jupyterlab>=4.3.5",

scripts/build.ps1

@@ -1 +1,73 @@
-pdm build -d build/
+pdm build --no-sdist -d build/
+
+# Configuration
+$sourceDir = ".\build"
+$destDir = "..\01_releases\runtime"
+$packagePrefix = "delta_barth-"
+$packageSuffix = "-py3-none-any.whl"
+
+# Ensure destination exists
+if (-not (Test-Path $destDir)) {
+    New-Item -ItemType Directory -Path $destDir | Out-Null
+}
+
+# === Build Regex Pattern ===
+$escapedSuffix = [regex]::Escape($packageSuffix)
+
+# Match versions like 1.2.3 or 1.2.3.beta or 1.2.3.beta1
+# Capture the full version as one string, including the optional pre-release after a dot
+$pattern = "^$packagePrefix(?<version>\d+\.\d+\.\d+(?:\.[a-zA-Z0-9\-]+)?)$escapedSuffix$"
+
+Write-Host "Using pattern: $pattern"
+
+# === Get and Filter Files ===
+$allFiles = Get-ChildItem -Path $sourceDir -File
+$matchingFiles = @()
+
+foreach ($file in $allFiles) {
+    if ($file.Name -match $pattern) {
+        $version = $Matches['version']
+        $matchingFiles += [PSCustomObject]@{
+            File = $file
+            Version = $version
+        }
+        Write-Host "Matched: $($file.Name) -> Version: $version"
+    } else {
+        Write-Host "No match: $($file.Name)"
+    }
+}
+
+if ($matchingFiles.Count -eq 0) {
+    Write-Host "No matching package files found."
+    return
+}
+
+# === Convert version strings to sortable format ===
+function Convert-VersionForSort($v) {
+    # Split by dot: e.g., 1.2.3.beta -> [1, 2, 3, "beta"]
+    $parts = $v -split '\.'
+
+    $major = [int]$parts[0]
+    $minor = [int]$parts[1]
+    $patch = [int]$parts[2]
+    $pre   = if ($parts.Count -gt 3) { $parts[3] } else { "~" }  # "~" to ensure stable > prerelease
+
+    return [PSCustomObject]@{
+        Major = $major
+        Minor = $minor
+        Patch = $patch
+        Pre   = $pre
+    }
+}
+
+# === Sort by semantic version + pre-release ===
+$latest = $matchingFiles | Sort-Object {
+    Convert-VersionForSort $_.Version
+} -Descending | Select-Object -First 1
+
+# === Copy and rename to .zip ===
+$baseName = [System.IO.Path]::GetFileNameWithoutExtension($latest.File.Name)
+$newFileName = "$baseName.zip"
+$destPath = Join-Path $destDir $newFileName
+
+Copy-Item -Path $latest.File.FullName -Destination $destPath

src/delta_barth/__init__.py

@@ -0,0 +1,3 @@
+import pip_system_certs.wrapt_requests
+
+pip_system_certs.wrapt_requests.inject_truststore()

src/delta_barth/analysis/forecast.py

@@ -9,16 +9,10 @@ from datetime import datetime as Datetime
 from typing import TYPE_CHECKING, Final, TypeAlias, cast
 
 import joblib
-import joblib.externals
-import joblib.externals.loky
-import joblib.externals.loky.backend
-import joblib.externals.loky.backend.popen_loky_win32
 import numpy as np
 import pandas as pd
 import scipy.stats
 import sqlalchemy as sql
-
-# --- new: for calculating timedelta
 from dateutil.relativedelta import relativedelta
 from sklearn.metrics import mean_absolute_error, r2_score
 from sklearn.model_selection import KFold, RandomizedSearchCV
@@ -198,6 +192,9 @@ def _process_sales(
 
     DATE_FEAT: Final[str] = "buchungs_datum"
     SALES_FEAT: Final[str] = "betrag"
+
+    data[DATE_FEAT] = pd.to_datetime(data[DATE_FEAT], errors="coerce")
+    data = data.dropna(subset=["buchungs_datum"])
     df_filter = data[(data["betrag"] > 0)]
     df_cust = df_filter.copy()
     df_cust = df_cust.sort_values(by=DATE_FEAT).reset_index()
@@ -409,13 +406,13 @@ def _export_on_fail(
 
 def pipeline_sales_forecast(
     session: Session,
-    company_id: int | None = None,
+    company_ids: list[int] | None = None,
     start_date: Datetime | None = None,
 ) -> SalesPrognosisResultsExport:
     logger_pipelines.info("[PIPELINES] Starting main sales forecast pipeline...")
     response, status = get_sales_prognosis_data(
         session,
-        company_id=company_id,
+        company_ids=company_ids,
         start_date=start_date,
     )
     if status != STATUS_HANDLER.SUCCESS:
@@ -442,7 +439,7 @@ def pipeline_sales_forecast(
     pipe = _process_sales(
         pipe,
         min_num_data_points=SALES_MIN_NUM_DATAPOINTS,
-        base_num_data_points_months=SESSION.cfg.forecast.threshold_month_data_points,
+        base_num_data_points_months=session.cfg.forecast.threshold_month_data_points,
     )
     if pipe.statistics is not None:
         res = _write_sales_forecast_stats_wrapped(pipe.statistics)

src/delta_barth/api/requests.py

@@ -7,18 +7,20 @@ import requests
 from dopt_basics.io import combine_route
 from pydantic import BaseModel, PositiveInt, SkipValidation
 
-from delta_barth.constants import API_CON_TIMEOUT
+from delta_barth.constants import API_CON_TIMEOUT, MAX_LOGIN_RETRIES
 from delta_barth.errors import STATUS_HANDLER
 from delta_barth.types import DelBarApiError, ExportResponse, ResponseType, Status
 
 if TYPE_CHECKING:
+    from requests import Response
+
     from delta_barth.session import Session
 
 
 # ** sales data
 # ** import
 class SalesPrognosisRequestP(BaseModel):
-    FirmaId: SkipValidation[int | None]
+    FirmaIds: SkipValidation[list[int] | None]
     BuchungsDatum: SkipValidation[Datetime | None]
 
 
@@ -53,29 +55,37 @@ class SalesPrognosisResultsExport(ExportResponse):
 
 def get_sales_prognosis_data(
     session: Session,
-    company_id: int | None = None,
+    company_ids: list[int] | None = None,
     start_date: Datetime | None = None,
 ) -> tuple[SalesPrognosisResponse, Status]:
-    _, status = session.assert_login()
-    if status != STATUS_HANDLER.SUCCESS:
-        response = SalesPrognosisResponse(daten=tuple())
-        return response, status
-
     ROUTE: Final[str] = "verkauf/umsatzprognosedaten"
     URL: Final = combine_route(session.base_url, ROUTE)
 
     sales_prog_req = SalesPrognosisRequestP(
-        FirmaId=company_id,
+        FirmaIds=company_ids,
         BuchungsDatum=start_date,
     )
     empty_response = SalesPrognosisResponse(daten=tuple())
+    if not session.logged_in:
+        _, status = session.login()
+        if status != STATUS_HANDLER.SUCCESS:
+            return empty_response, status
+
+    resp: Response | None = None
     try:
+        for attempt in range(1, (MAX_LOGIN_RETRIES + 1)):
             resp = requests.get(
                 URL,
                 params=sales_prog_req.model_dump(mode="json", exclude_none=True),
                 headers=session.headers,  # type: ignore[argumentType]
                 timeout=API_CON_TIMEOUT,
             )
+            if resp.status_code == 401:
+                _, status = session.relogin()
+                if status != STATUS_HANDLER.SUCCESS and attempt == MAX_LOGIN_RETRIES:
+                    return empty_response, status
+                continue
+            break
     except requests.exceptions.Timeout:
         return empty_response, STATUS_HANDLER.pipe_states.CONNECTION_TIMEOUT
     except requests.exceptions.RequestException:
@@ -83,6 +93,7 @@ def get_sales_prognosis_data(
 
     response: SalesPrognosisResponse
     status: Status
+    assert resp is not None, "tried to use not defined response"
     if resp.status_code == 200:
         response = SalesPrognosisResponse(**resp.json())
         status = STATUS_HANDLER.SUCCESS

src/delta_barth/constants.py

@@ -31,7 +31,7 @@ DEPLOYMENT_STATUS: Final[bool] = deployment_status
 
 
 # ** databases
-DB_ECHO: Final[bool] = True
+DB_ECHO: Final[bool] = False
 
 # ** error handling
 DEFAULT_INTERNAL_ERR_CODE: Final[int] = 100
@@ -50,7 +50,9 @@ class KnownDelBarApiErrorCodes(enum.Enum):
 
 
 # ** API
-API_CON_TIMEOUT: Final[float] = 10.0  # secs to response
+API_CON_TIMEOUT: Final[float] = 20.0  # secs to response
+MAX_LOGIN_RETRIES: Final[int] = 2
+
 # ** API response parsing
 # ** column mapping [API-Response --> Target-Features]
 COL_MAP_SALES_PROGNOSIS: Final[DualDict[str, str]] = DualDict(

src/delta_barth/pipelines.py

@@ -44,14 +44,14 @@ def _write_performance_metrics_wrapped(
 
 
 def pipeline_sales_forecast(
-    company_id: int | None,
+    company_ids: list[int] | None,
     start_date: Datetime | None,
 ) -> JsonExportResponse:
     PIPELINE_NAME: Final[str] = "sales_forecast"
     logger.info("[EXT-CALL PIPELINES] Starting main sales forecast pipeline...")
     t_start = time.perf_counter_ns()
     result = forecast.pipeline_sales_forecast(
-        SESSION, company_id=company_id, start_date=start_date
+        SESSION, company_ids=company_ids, start_date=start_date
     )
     export = JsonExportResponse(result.model_dump_json())
     t_end = time.perf_counter_ns()

src/delta_barth/session.py

@@ -292,44 +292,11 @@ class Session:
 
         return None, status
 
-    def assert_login(
+    def relogin(
         self,
     ) -> tuple[LoginResponse, Status]:
-        # check if login token is still valid
-        # re-login if necessary
         if self.session_token is None:
             return self.login()
 
-        # use known endpoint which requires a valid token in its header
-        # evaluate the response to decide if:
-        # current token is still valid, token is not valid, other errors occurred
-        ROUTE: Final[str] = "verkauf/umsatzprognosedaten"
-        URL: Final = combine_route(self.base_url, ROUTE)
-        params: dict[str, int] = {"FirmaId": 999999}
-        empty_response = LoginResponse(token="")
-        try:
-            resp = requests.get(
-                URL,
-                params=params,
-                headers=self.headers,  # type: ignore
-                timeout=API_CON_TIMEOUT,
-            )
-        except requests.exceptions.Timeout:  # pragma: no cover
-            return empty_response, STATUS_HANDLER.pipe_states.CONNECTION_TIMEOUT
-        except requests.exceptions.RequestException:  # pragma: no cover
-            return empty_response, STATUS_HANDLER.pipe_states.CONNECTION_ERROR
-
-        response: LoginResponse
-        status: Status
-        if resp.status_code == 200:
-            response = LoginResponse(token=self.session_token)
-            status = STATUS_HANDLER.SUCCESS
-        elif resp.status_code == 401:
         self._remove_session_token()
-            response, status = self.login()
+        return self.login()
-        else:
-            response = empty_response
-            err = DelBarApiError(status_code=resp.status_code, **resp.json())
-            status = STATUS_HANDLER.api_error(err)
-
-        return response, status

tests/analysis/test_forecast.py

@@ -279,6 +279,28 @@ def test_process_sales_Success(sales_data_real_preproc):
     assert pipe.statistics.xgb_params is not None
 
 
+@pytest.mark.forecast
+def test_process_sales_InvalidDates(sales_data_real_preproc):
+    false_date = Datetime(2519, 6, 30)
+    data = sales_data_real_preproc.copy()
+    data = data.iloc[:20, :]
+    data["buchungs_datum"] = data["buchungs_datum"].astype(object)
+    data.at[0, "buchungs_datum"] = false_date
+    assert data["buchungs_datum"].dtype.char == "O"
+    assert len(data) == 20
+    pipe = PipeResult(data, STATUS_HANDLER.SUCCESS)
+    pipe = fc._process_sales(
+        pipe,
+        min_num_data_points=36,
+        base_num_data_points_months=36,
+    )
+    assert pipe.status != STATUS_HANDLER.SUCCESS
+    assert pipe.status == STATUS_HANDLER.pipe_states.TOO_FEW_POINTS
+    assert pipe.data is None
+    assert pipe.results is None
+    assert pipe.statistics is not None
+
+
 @pytest.mark.forecast
 def test_process_sales_FailTooFewPoints(sales_data_real_preproc):
     data = sales_data_real_preproc.copy()
@@ -432,6 +454,9 @@ def test_export_on_fail():
 
 @patch("delta_barth.session.CFG_HOT_RELOAD", False)
 def test_pipeline_sales_forecast_SuccessDbWrite(exmpl_api_sales_prognosis_resp, session):
+    assert session.cfg.forecast.threshold_month_data_points is not None
+    date = Datetime(2023, 8, 15)
+    company_ids = [5661, 1027, 1024]
     with (
         patch(
             "delta_barth.analysis.forecast.get_sales_prognosis_data",
@@ -440,7 +465,7 @@ def test_pipeline_sales_forecast_SuccessDbWrite(exmpl_api_sales_prognosis_resp,
     ):
         get_mock.return_value = exmpl_api_sales_prognosis_resp, STATUS_HANDLER.SUCCESS
         sess_mock.cfg.forecast.threshold_month_data_points = 1
-        result = fc.pipeline_sales_forecast(None)  # type: ignore
+        result = fc.pipeline_sales_forecast(session, company_ids, date)  # type: ignore
     assert result.status == STATUS_HANDLER.SUCCESS
     assert len(result.response.daten) > 0
 

tests/api/test_requests.py

@@ -4,44 +4,41 @@ import pytest
 import requests
 
 from delta_barth.api import requests as requests_
-from delta_barth.api.common import LoginResponse
 
 
 @pytest.mark.api_con_required
 def test_get_sales_prognosis_data_Success(session):
-    resp, status = session.login()
+    # do not login: let routine do it
     # test without company ID
-    assert status.code == 0
+    date = Datetime(2023, 12, 15)
-    date = Datetime(2022, 6, 1)
     resp, status = requests_.get_sales_prognosis_data(session, None, date)
     assert status.code == 0
     assert len(resp.daten) > 0
-    date = Datetime(2030, 1, 1)
+    date = Datetime(2520, 1, 1)
     resp, status = requests_.get_sales_prognosis_data(session, None, date)
     assert status.code == 0
     assert len(resp.daten) == 0
     # test with company ID
     assert status.code == 0
-    date = Datetime(2022, 6, 1)
+    date = Datetime(2023, 8, 15)
-    company_id = 1024
+    company_ids = [5661, 1027]
-    resp, status = requests_.get_sales_prognosis_data(session, company_id, date)
+    resp, status = requests_.get_sales_prognosis_data(session, company_ids, date)
     assert status.code == 0
     assert len(resp.daten) > 0
-    date = Datetime(2030, 1, 1)
+    date = Datetime(2520, 1, 1)
-    resp, status = requests_.get_sales_prognosis_data(session, company_id, date)
+    resp, status = requests_.get_sales_prognosis_data(session, company_ids, date)
     assert status.code == 0
     assert len(resp.daten) == 0
     # test with non-existent company ID
     assert status.code == 0
     date = Datetime(2022, 6, 1)
-    company_id = 1000024
+    company_ids = [1000024]
-    resp, status = requests_.get_sales_prognosis_data(session, company_id, date)
+    resp, status = requests_.get_sales_prognosis_data(session, company_ids, date)
-    # TODO check if this behaviour is still considered "successful"
     assert status.code == 0
     assert len(resp.daten) == 0
     # test without date
-    company_id = 1024
+    company_ids = [1024]
-    resp, status = requests_.get_sales_prognosis_data(session, company_id, None)
+    resp, status = requests_.get_sales_prognosis_data(session, company_ids, None)
     assert status.code == 0
     assert len(resp.daten) > 0
     # test without filters
@@ -54,12 +51,11 @@ def test_get_sales_prognosis_data_Success(session):
 
 
 @pytest.mark.api_con_required
-def test_get_sales_prognosis_data_FailLogin(session, mock_get):
+def test_get_sales_prognosis_data_NoAuth(session, mock_get):
-    session.login()
+    code = 401
-    code = 500
     json = {
         "message": "ServerError",
-        "code": "TestExternalServerError",
+        "code": "TestFailAuth",
         "hints": "TestCase",
     }
     mock_get.return_value.status_code = code
@@ -76,6 +72,36 @@ def test_get_sales_prognosis_data_FailLogin(session, mock_get):
     assert status.api_server_error.hints == json["hints"]
 
 
+def test_get_sales_prognosis_data_FailLogin(session, mock_get, mock_put):
+    code = 401
+    json = {
+        "message": "ServerError",
+        "code": "TestFailAuth",
+        "hints": "TestCase",
+    }
+    mock_get.return_value.status_code = code
+    mock_get.return_value.json.return_value = json
+
+    code_put = 500
+    json_put = {
+        "message": "ServerError",
+        "code": "TestUnknownError",
+        "hints": "TestCase",
+    }
+    mock_put.return_value.status_code = code_put
+    mock_put.return_value.json.return_value = json_put
+
+    resp, status = requests_.get_sales_prognosis_data(session, None, None)
+    assert resp is not None
+    assert len(resp.daten) == 0
+    assert status.code == 400
+    assert status.api_server_error is not None
+    assert status.api_server_error.status_code == code_put
+    assert status.api_server_error.message == json_put["message"]
+    assert status.api_server_error.code == json_put["code"]
+    assert status.api_server_error.hints == json_put["hints"]
+
+
 @pytest.mark.api_con_required
 def test_get_sales_prognosis_data_FailApiServer(session, mock_get):
     code = 405
@@ -101,11 +127,6 @@ def test_get_sales_prognosis_data_FailApiServer(session, mock_get):
 def test_get_sales_prognosis_data_FailGetTimeout(session, mock_get):
     mock_get.side_effect = requests.exceptions.Timeout("Test timeout")
 
-    def assert_login():
-        return LoginResponse(token=""), requests_.STATUS_HANDLER.SUCCESS
-
-    session.assert_login = assert_login
-
     resp, status = requests_.get_sales_prognosis_data(session, None, None)
     assert resp is not None
     assert len(resp.daten) == 0
@@ -115,11 +136,6 @@ def test_get_sales_prognosis_data_FailGetTimeout(session, mock_get):
 def test_get_sales_prognosis_data_FailGetRequestException(session, mock_get):
     mock_get.side_effect = requests.exceptions.RequestException("Test not timeout")
 
-    def assert_login():
-        return LoginResponse(token=""), requests_.STATUS_HANDLER.SUCCESS
-
-    session.assert_login = assert_login
-
     resp, status = requests_.get_sales_prognosis_data(session, None, None)
     assert resp is not None
     assert len(resp.daten) == 0

tests/test_pipelines.py

@@ -1,4 +1,5 @@
 import json
+from datetime import datetime as Datetime
 from unittest.mock import patch
 
 import pytest
@@ -47,6 +48,8 @@ def test_write_performance_metrics_FailStartingTime(session):
 
 @patch("delta_barth.session.CFG_HOT_RELOAD", False)
 def test_sales_prognosis_pipeline(exmpl_api_sales_prognosis_resp, session, monkeypatch):
+    date = Datetime(2023, 8, 15)
+    company_ids = [5661, 1027, 1024]
     with (
         patch(
             "delta_barth.analysis.forecast.get_sales_prognosis_data",
@@ -56,7 +59,7 @@ def test_sales_prognosis_pipeline(exmpl_api_sales_prognosis_resp, session, monke
     ):
         get_mock.return_value = (exmpl_api_sales_prognosis_resp, STATUS_HANDLER.SUCCESS)
         sess_mock.cfg.forecast.threshold_month_data_points = 1
-        json_export = pl.pipeline_sales_forecast(None, None)
+        json_export = pl.pipeline_sales_forecast(company_ids, date)
 
     assert isinstance(json_export, str)
     parsed_resp = json.loads(json_export)

tests/test_session.py

@@ -314,11 +314,11 @@ def test_login_logout_FailApiServer(session, mock_put):
 
 
 @pytest.mark.api_con_required
-def test_assert_login_SuccessLoggedOut(session):
+def test_relogin_SuccessLoggedOut(session):
     assert session.session_token is None
     assert session._creds is not None
     # test logged out state
-    resp, status = session.assert_login()
+    resp, status = session.relogin()
     assert resp is not None
     assert status.code == 0
     assert session.session_token is not None
@@ -327,74 +327,17 @@ def test_assert_login_SuccessLoggedOut(session):
 
 
 @pytest.mark.api_con_required
-def test_assert_login_SuccessStillLoggedIn(session):
+def test_relogin_SuccessStillLoggedIn(session):
     assert session.session_token is None
     assert session._creds is not None
     resp, status = session.login()
-    resp, status = session.assert_login()
+    old_token = session.session_token
+    assert old_token is not None
+    resp, status = session.relogin()
     assert resp is not None
     assert status.code == 0
     assert session.session_token is not None
+    assert session.session_token != old_token
+
     resp, status = session.logout()
     assert status.code == 0
-
-
-@pytest.mark.api_con_required
-def test_assert_login_ReloginNoValidAuth(session, mock_get):
-    code = 401
-    json = {
-        "message": "AuthentificationError",
-        "code": "TestAssertLoginAfter",
-        "hints": "TestCase",
-    }
-    mock_get.return_value.status_code = code
-    mock_get.return_value.json.return_value = json
-
-    resp, status = session.login()
-
-    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
-
-
-@pytest.mark.api_con_required
-def test_assert_login_ReloginWrongToken(session):
-    # triggers code 401
-    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
-
-
-@pytest.mark.api_con_required
-def test_assert_login_FailApiServer(session, mock_get):
-    code = 500
-    json = {
-        "message": "ServerError",
-        "code": "TestExternalServerError",
-        "hints": "TestCase",
-    }
-    mock_get.return_value.status_code = code
-    mock_get.return_value.json.return_value = json
-
-    resp, status = session.login()
-
-    resp, status = session.assert_login()
-    assert resp is not None
-    assert not resp.token
-    assert status.code == 400
-    assert status.api_server_error is not None
-    assert status.api_server_error.status_code == code
-    assert status.api_server_error.message == json["message"]
-    assert status.api_server_error.code == json["code"]
-    assert status.api_server_error.hints == json["hints"]