airbyte-source-kyriba 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

unit_tests/test_cash_flows.py

@@ -1,100 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-
-from datetime import date
-from unittest.mock import MagicMock
-
-import requests
-from airbyte_cdk.models import SyncMode
-from pytest import fixture
-from source_kyriba.source import CashFlows
-
-from .test_streams import config
-
-
-@fixture
-def patch_base_class(mocker):
-    # Mock abstract methods to enable instantiating abstract class
-    mocker.patch.object(CashFlows, "primary_key", "test_primary_key")
-    mocker.patch.object(CashFlows, "__abstractmethods__", set())
-
-
-def test_path(patch_base_class):
-    stream = CashFlows(**config())
-    assert stream.path() == "cash-flows"
-
-
-def test_stream_slices_new(patch_base_class):
-    stream = CashFlows(**config())
-    stream.start_date = date(2021, 1, 1)
-    stream.end_date = date(2021, 1, 3)
-    inputs = {"sync_mode": SyncMode.incremental, "cursor_field": [], "stream_state": {}}
-    expected_stream_slice = [
-        {
-            "startDate": "2021-01-01",
-            "endDate": "2021-01-01",
-        },
-        {
-            "startDate": "2021-01-02",
-            "endDate": "2021-01-02",
-        },
-        {
-            "startDate": "2021-01-03",
-            "endDate": "2021-01-03",
-        },
-    ]
-    assert stream.stream_slices(**inputs) == expected_stream_slice
-
-
-def test_stream_slices_state(patch_base_class):
-    stream = CashFlows(**config())
-    stream.start_date = date.fromisoformat("2021-01-01")
-    stream.end_date = date.fromisoformat("2021-01-03")
-    inputs = {"sync_mode": SyncMode.incremental, "cursor_field": [], "stream_state": {"updateDateTime": "2021-01-02T00:00:00Z"}}
-    expected_stream_slice = [
-        {
-            "startDate": "2021-01-02",
-            "endDate": "2021-01-02",
-        },
-        {
-            "startDate": "2021-01-03",
-            "endDate": "2021-01-03",
-        },
-    ]
-    assert stream.stream_slices(**inputs) == expected_stream_slice
-
-
-def test_all_request_params(patch_base_class):
-    stream = CashFlows(**config())
-    inputs = {
-        "stream_state": {
-            "updateDateTime": "2022-01-01T00:00:00Z",
-        },
-        "stream_slice": {
-            "startDate": "2021-01-01",
-            "endDate": "2022-01-02",
-        },
-        "next_page_token": {
-            "page.offset": 1000,
-        },
-    }
-    expected = {
-        "sort": "updateDateTime",
-        "page.offset": 1000,
-        "filter": "updateDateTime=gt='2022-01-01T00:00:00Z'",
-        "dateType": "UPDATE",
-        "page.limit": 1000,
-        "startDate": "2021-01-01",
-        "endDate": "2022-01-02",
-    }
-    assert stream.request_params(**inputs) == expected
-
-
-def test_parse_response(patch_base_class):
-    stream = CashFlows(**config())
-    resp = requests.Response()
-    resp_data = {"results": [{"date": {"updateDateTime": "2022-03-01T00:00:00Z"}}]}
-    resp.json = MagicMock(return_value=resp_data)
-    assert next(stream.parse_response(resp)) == {"updateDateTime": "2022-03-01T00:00:00Z"}

unit_tests/test_incremental_streams.py

@@ -1,72 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-
-from airbyte_cdk.models import SyncMode
-from pytest import fixture
-from source_kyriba.source import IncrementalKyribaStream
-
-from .test_streams import config
-
-
-@fixture
-def patch_incremental_base_class(mocker):
-    # Mock abstract methods to enable instantiating abstract class
-    mocker.patch.object(IncrementalKyribaStream, "path", "v0/example_endpoint")
-    mocker.patch.object(IncrementalKyribaStream, "primary_key", "test_primary_key")
-    mocker.patch.object(IncrementalKyribaStream, "__abstractmethods__", set())
-
-
-def test_cursor_field(patch_incremental_base_class):
-    stream = IncrementalKyribaStream(**config())
-    expected_cursor_field = "updateDateTime"
-    assert stream.cursor_field == expected_cursor_field
-
-
-def test_get_updated_state(patch_incremental_base_class):
-    stream = IncrementalKyribaStream(**config())
-    inputs = {
-        "current_stream_state": {"updateDateTime": "2022-01-01T00:00:00Z"},
-        "latest_record": {"updateDateTime": "2022-01-01T00:00:01Z"},
-    }
-    expected_state = {"updateDateTime": "2022-01-01T00:00:01Z"}
-    assert stream.get_updated_state(**inputs) == expected_state
-
-
-def test_stream_slices(patch_incremental_base_class):
-    stream = IncrementalKyribaStream(**config())
-    inputs = {"sync_mode": SyncMode.incremental, "cursor_field": [], "stream_state": {}}
-    expected_stream_slice = [None]
-    assert stream.stream_slices(**inputs) == expected_stream_slice
-
-
-def test_supports_incremental(patch_incremental_base_class, mocker):
-    mocker.patch.object(IncrementalKyribaStream, "cursor_field", "dummy_field")
-    stream = IncrementalKyribaStream(**config())
-    assert stream.supports_incremental
-
-
-def test_source_defined_cursor(patch_incremental_base_class):
-    stream = IncrementalKyribaStream(**config())
-    assert stream.source_defined_cursor
-
-
-def test_stream_checkpoint_interval(patch_incremental_base_class):
-    stream = IncrementalKyribaStream(**config())
-    expected_checkpoint_interval = 100
-    assert stream.state_checkpoint_interval == expected_checkpoint_interval
-
-
-def test_all_request_params(patch_incremental_base_class):
-    stream = IncrementalKyribaStream(**config())
-    inputs = {"stream_state": {"updateDateTime": "2022-01-01T00:00:00Z"}, "stream_slice": {}, "next_page_token": {"page.offset": 100}}
-    expected = {"sort": "updateDateTime", "page.offset": 100, "filter": "updateDateTime=gt='2022-01-01T00:00:00Z'"}
-    assert stream.request_params(**inputs) == expected
-
-
-def test_min_request_params(patch_incremental_base_class):
-    stream = IncrementalKyribaStream(**config())
-    inputs = {"stream_state": {}, "stream_slice": {}, "next_page_token": {}}
-    expected = {"sort": "updateDateTime", "filter": "updateDateTime=gt='2022-01-01T00:00:00Z'"}
-    assert stream.request_params(**inputs) == expected

unit_tests/test_source.py

@@ -1,27 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from unittest.mock import MagicMock
-
-from source_kyriba.source import KyribaClient, SourceKyriba
-
-config = {
-    "username": "username",
-    "password": "password",
-    "domain": "demo.kyriba.com",
-    "start_date": "2022-01-01",
-}
-
-def test_check_connection(mocker):
-    source = SourceKyriba()
-    KyribaClient.login = MagicMock()
-    logger_mock = MagicMock()
-    assert source.check_connection(logger_mock, config) == (True, None)
-
-
-def test_streams(mocker):
-    source = SourceKyriba()
-    streams = source.streams(config)
-    expected_streams_number = 6
-    assert len(streams) == expected_streams_number

unit_tests/test_streams.py

@@ -1,121 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from http import HTTPStatus
-from unittest.mock import MagicMock
-
-import pytest
-import requests
-from airbyte_cdk.sources.streams.http.requests_native_auth import TokenAuthenticator
-from source_kyriba.source import KyribaClient, KyribaStream
-
-
-@pytest.fixture
-def patch_base_class(mocker):
-    # Mock abstract methods to enable instantiating abstract class
-    mocker.patch.object(KyribaStream, "path", "v0/example_endpoint")
-    mocker.patch.object(KyribaStream, "primary_key", "test_primary_key")
-    mocker.patch.object(KyribaStream, "__abstractmethods__", set())
-
-
-def config():
-    gateway_url = "https://demo.kyriba.com/gateway"
-    client = KyribaClient("username", "password", gateway_url)
-    client.login = MagicMock(return_value=TokenAuthenticator("token"))
-    return {
-        "gateway_url": "https://demo.kyriba.com/gateway",
-        "client": client,
-        "start_date": "2022-01-01",
-        "end_date": "2022-03-01",
-    }
-
-
-def test_request_params(patch_base_class):
-    stream = KyribaStream(**config())
-    inputs = {"stream_slice": None, "stream_state": None, "next_page_token": {"page.offset": 100}}
-    expected_params = {"page.offset": 100}
-    assert stream.request_params(**inputs) == expected_params
-
-
-def test_next_page_token(patch_base_class):
-    stream = KyribaStream(**config())
-    # TODO: replace this with your input parameters
-    resp = requests.Response()
-    resp_dict = {
-        "metadata": {
-            "links": {"next": "https://next"},
-            "pageOffset": 0,
-            "pageLimit": 100,
-        }
-    }
-    resp.json = MagicMock(return_value=resp_dict)
-    inputs = {"response": resp}
-    expected_token = {"page.offset": 100}
-    assert stream.next_page_token(**inputs) == expected_token
-
-
-def test_parse_response(patch_base_class):
-    stream = KyribaStream(**config())
-    resp = requests.Response()
-    resp_dict = {"results": [{"uuid": "uuid"}]}
-    resp.json = MagicMock(return_value=resp_dict)
-    inputs = {"response": resp}
-    expected_parsed_object = {"uuid": "uuid"}
-    assert next(stream.parse_response(**inputs)) == expected_parsed_object
-
-
-def test_request_headers(patch_base_class):
-    stream = KyribaStream(**config())
-    inputs = {"stream_slice": None, "stream_state": None, "next_page_token": None}
-    expected_headers = {}
-    assert stream.request_headers(**inputs) == expected_headers
-
-
-def test_http_method(patch_base_class):
-    stream = KyribaStream(**config())
-    expected_method = "GET"
-    assert stream.http_method == expected_method
-
-
-@pytest.mark.parametrize(
-    ("http_status", "should_retry"),
-    [
-        (HTTPStatus.OK, False),
-        (HTTPStatus.BAD_REQUEST, False),
-        (HTTPStatus.TOO_MANY_REQUESTS, True),
-        (HTTPStatus.INTERNAL_SERVER_ERROR, True),
-    ],
-)
-def test_should_retry(patch_base_class, http_status, should_retry):
-    response_mock = MagicMock()
-    response_mock.status_code = http_status
-    stream = KyribaStream(**config())
-    assert stream.should_retry(response_mock) == should_retry
-
-
-def test_should_retry_401(patch_base_class):
-    response_mock = MagicMock()
-    response_mock.status_code = HTTPStatus.UNAUTHORIZED
-    cfg = config()
-    client = KyribaClient("username", "password", "https://gateway.url")
-    client.login = MagicMock(return_value=TokenAuthenticator("token"))
-    client.access_token = "token"
-    cfg["client"] = client
-    stream = KyribaStream(**cfg)
-    client.login.assert_called_once()
-    assert stream.should_retry(response_mock)
-
-
-def test_backoff_time(patch_base_class):
-    response_mock = MagicMock()
-    stream = KyribaStream(**config())
-    expected_backoff_time = None
-    assert stream.backoff_time(response_mock) == expected_backoff_time
-
-
-def test_unnest(patch_base_class):
-    stream = KyribaStream(**config())
-    data = {"uuid": "uuid", "nested": {"date": "date"}}
-    expected = {"uuid": "uuid", "date": "date"}
-    assert stream.unnest("nested", data) == expected