Merge branch 'development' into jorwoods/vf_params

Author: jorwoods

pyproject.toml

@@ -33,8 +33,7 @@ repository = "https://github.com/tableau/server-client-python"
 
 [project.optional-dependencies]
 test = ["black==24.8", "build", "mypy==1.4", "pytest>=7.0", "pytest-cov", "pytest-subtests",
-    "requests-mock>=1.0,<2.0"]
-
+    "requests-mock>=1.0,<2.0", "types-requests>=2.32.4.20250913"]
 [tool.black]
 line-length = 120
 target-version = ['py39', 'py310', 'py311', 'py312', 'py313']

tableauserverclient/server/endpoint/flow_task_endpoint.py

@@ -18,7 +18,7 @@ def baseurl(self) -> str:
         return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/tasks/flows"
 
     @api(version="3.22")
-    def create(self, flow_item: TaskItem) -> TaskItem:
+    def create(self, flow_item: TaskItem) -> bytes:
         if not flow_item:
             error = "No flow provided"
             raise ValueError(error)

test/http/test_http_requests.py

@@ -1,3 +1,4 @@
+import pytest
 import tableauserverclient as TSC
 import unittest
 import requests
@@ -27,91 +28,103 @@ def __init__(self, status_code):
     return MockResponse(200)
 
 
-class ServerTests(unittest.TestCase):
-    def test_init_server_model_empty_throws(self):
-        with self.assertRaises(TypeError):
-            server = TSC.Server()
-
-    def test_init_server_model_no_protocol_defaults_htt(self):
-        server = TSC.Server("fake-url")
-
-    def test_init_server_model_valid_server_name_works(self):
-        server = TSC.Server("http://fake-url")
-
-    def test_init_server_model_valid_https_server_name_works(self):
-        # by default, it will just set the version to 2.3
-        server = TSC.Server("https://fake-url")
-
-    def test_init_server_model_bad_server_name_not_version_check(self):
-        server = TSC.Server("fake-url", use_server_version=False)
-
-    @mock.patch("requests.sessions.Session.get", side_effect=mocked_requests_get)
-    def test_init_server_model_bad_server_name_do_version_check(self, mock_get):
-        server = TSC.Server("fake-url", use_server_version=True)
-
-    def test_init_server_model_bad_server_name_not_version_check_random_options(self):
-        # with self.assertRaises(MissingSchema):
-        server = TSC.Server("fake-url", use_server_version=False, http_options={"foo": 1})
-
-    def test_init_server_model_bad_server_name_not_version_check_real_options(self):
-        # with self.assertRaises(ValueError):
-        server = TSC.Server("fake-url", use_server_version=False, http_options={"verify": False})
-
-    def test_http_options_skip_ssl_works(self):
-        http_options = {"verify": False}
-        server = TSC.Server("http://fake-url")
-        server.add_http_options(http_options)
-
-    def test_http_options_multiple_options_works(self):
-        http_options = {"verify": False, "birdname": "Parrot"}
-        server = TSC.Server("http://fake-url")
-        server.add_http_options(http_options)
-
-    # ValueError: dictionary update sequence element #0 has length 1; 2 is required
-    def test_http_options_multiple_dicts_fails(self):
-        http_options_1 = {"verify": False}
-        http_options_2 = {"birdname": "Parrot"}
-        server = TSC.Server("http://fake-url")
-        with self.assertRaises(ValueError):
-            server.add_http_options([http_options_1, http_options_2])
-
-    # TypeError: cannot convert dictionary update sequence element #0 to a sequence
-    def test_http_options_not_sequence_fails(self):
-        server = TSC.Server("http://fake-url")
-        with self.assertRaises(ValueError):
-            server.add_http_options({1, 2, 3})
-
-    def test_validate_connection_http(self):
-        url = "http://cookies.com"
-        server = TSC.Server(url)
-        server.validate_connection_settings()
-        self.assertEqual(url, server.server_address)
-
-    def test_validate_connection_https(self):
-        url = "https://cookies.com"
-        server = TSC.Server(url)
-        server.validate_connection_settings()
-        self.assertEqual(url, server.server_address)
-
-    def test_validate_connection_no_protocol(self):
-        url = "cookies.com"
-        fixed_url = "http://cookies.com"
-        server = TSC.Server(url)
-        server.validate_connection_settings()
-        self.assertEqual(fixed_url, server.server_address)
-
-
-class SessionTests(unittest.TestCase):
-    test_header = {"x-test": "true"}
-
-    @staticmethod
-    def session_factory():
-        session = requests.session()
-        session.headers.update(SessionTests.test_header)
-        return session
-
-    def test_session_factory_adds_headers(self):
-        test_request_bin = "http://capture-this-with-mock.com"
-        with requests_mock.mock() as m:
-            m.get(url="http://capture-this-with-mock.com/api/2.4/serverInfo", request_headers=SessionTests.test_header)
-            server = TSC.Server(test_request_bin, use_server_version=True, session_factory=SessionTests.session_factory)
+def test_init_server_model_empty_throws():
+    with pytest.raises(TypeError):
+        server = TSC.Server()
+
+
+def test_init_server_model_no_protocol_defaults_htt():
+    server = TSC.Server("fake-url")
+
+
+def test_init_server_model_valid_server_name_works():
+    server = TSC.Server("http://fake-url")
+
+
+def test_init_server_model_valid_https_server_name_works():
+    # by default, it will just set the version to 2.3
+    server = TSC.Server("https://fake-url")
+
+
+def test_init_server_model_bad_server_name_not_version_check():
+    server = TSC.Server("fake-url", use_server_version=False)
+
+
+@mock.patch("requests.sessions.Session.get", side_effect=mocked_requests_get)
+def test_init_server_model_bad_server_name_do_version_check(mock_get):
+    server = TSC.Server("fake-url", use_server_version=True)
+
+
+def test_init_server_model_bad_server_name_not_version_check_random_options():
+    server = TSC.Server("fake-url", use_server_version=False, http_options={"foo": 1})
+
+
+def test_init_server_model_bad_server_name_not_version_check_real_options():
+    server = TSC.Server("fake-url", use_server_version=False, http_options={"verify": False})
+
+
+def test_http_options_skip_ssl_works():
+    http_options = {"verify": False}
+    server = TSC.Server("http://fake-url")
+    server.add_http_options(http_options)
+
+
+def test_http_options_multiple_options_works():
+    http_options = {"verify": False, "birdname": "Parrot"}
+    server = TSC.Server("http://fake-url")
+    server.add_http_options(http_options)
+
+
+# ValueError: dictionary update sequence element #0 has length 1; 2 is required
+def test_http_options_multiple_dicts_fails():
+    http_options_1 = {"verify": False}
+    http_options_2 = {"birdname": "Parrot"}
+    server = TSC.Server("http://fake-url")
+    with pytest.raises(ValueError):
+        server.add_http_options([http_options_1, http_options_2])
+
+
+# TypeError: cannot convert dictionary update sequence element #0 to a sequence
+def test_http_options_not_sequence_fails():
+    server = TSC.Server("http://fake-url")
+    with pytest.raises(ValueError):
+        server.add_http_options({1, 2, 3})
+
+
+def test_validate_connection_http():
+    url = "http://cookies.com"
+    server = TSC.Server(url)
+    server.validate_connection_settings()
+    assert url == server.server_address
+
+
+def test_validate_connection_https():
+    url = "https://cookies.com"
+    server = TSC.Server(url)
+    server.validate_connection_settings()
+    assert url == server.server_address
+
+
+def test_validate_connection_no_protocol():
+    url = "cookies.com"
+    fixed_url = "http://cookies.com"
+    server = TSC.Server(url)
+    server.validate_connection_settings()
+    assert fixed_url == server.server_address
+
+
+test_header = {"x-test": "true"}
+
+
+@pytest.fixture
+def session_factory() -> requests.Session:
+    session = requests.session()
+    session.headers.update(test_header)
+    return session
+
+
+def test_session_factory_adds_headers(session_factory):
+    test_request_bin = "http://capture-this-with-mock.com"
+    with requests_mock.mock() as m:
+        m.get(url="http://capture-this-with-mock.com/api/2.4/serverInfo", request_headers=test_header)
+        server = TSC.Server(test_request_bin, use_server_version=True, session_factory=lambda: session_factory)

test/models/test_repr.py

@@ -1,10 +1,10 @@
 import inspect
+from typing import Any
 
-from unittest import TestCase
 import _models  # type: ignore  # did not set types for this
 import tableauserverclient as TSC
 
-from typing import Any
+import pytest
 
 
 # ensure that all models that don't need parameters can be instantiated
@@ -31,21 +31,16 @@ def instantiate_class(name: str, obj: Any):
         print(f"Class '{name}' does not have a constructor (__init__ method).")
 
 
-class TestAllModels(TestCase):
-    # not all models have __repr__ yet: see above list
-    def test_repr_is_implemented(self):
-        m = _models.get_defined_models()
-        for model in m:
-            with self.subTest(model.__name__, model=model):
-                print(model.__name__, type(model.__repr__).__name__)
-                self.assertEqual(type(model.__repr__).__name__, "function")
+def is_concrete(obj: Any):
+    return inspect.isclass(obj) and not inspect.isabstract(obj)
 
-    # 2 - Iterate through the objects in the module
-    def test_by_reflection(self):
-        for class_name, obj in inspect.getmembers(TSC, is_concrete):
-            with self.subTest(class_name, obj=obj):
-                instantiate_class(class_name, obj)
 
+@pytest.mark.parametrize("class_name, obj", inspect.getmembers(TSC, is_concrete))
+def test_by_reflection(class_name, obj):
+    instantiate_class(class_name, obj)
 
-def is_concrete(obj: Any):
-    return inspect.isclass(obj) and not inspect.isabstract(obj)
+
+@pytest.mark.parametrize("model", _models.get_defined_models())
+def test_repr_is_implemented(model):
+    print(model.__name__, type(model.__repr__).__name__)
+    assert type(model.__repr__).__name__ == "function"

test/request_factory/test_datasource_requests.py

@@ -1,15 +1,13 @@
-import unittest
 import tableauserverclient as TSC
 import tableauserverclient.server.request_factory as TSC_RF
 from tableauserverclient import DatasourceItem
 
 
-class DatasourceRequestTests(unittest.TestCase):
-    def test_generate_xml(self):
-        datasource_item: TSC.DatasourceItem = TSC.DatasourceItem("name")
-        datasource_item.name = "a ds"
-        datasource_item.description = "described"
-        datasource_item.use_remote_query_agent = False
-        datasource_item.ask_data_enablement = DatasourceItem.AskDataEnablement.Enabled
-        datasource_item.project_id = "testval"
-        TSC_RF.RequestFactory.Datasource._generate_xml(datasource_item)
+def test_generate_xml():
+    datasource_item: TSC.DatasourceItem = TSC.DatasourceItem("name")
+    datasource_item.name = "a ds"
+    datasource_item.description = "described"
+    datasource_item.use_remote_query_agent = False
+    datasource_item.ask_data_enablement = DatasourceItem.AskDataEnablement.Enabled
+    datasource_item.project_id = "testval"
+    TSC_RF.RequestFactory.Datasource._generate_xml(datasource_item)

test/request_factory/test_workbook_requests.py

@@ -1,55 +1,58 @@
-import unittest
 import tableauserverclient as TSC
 import tableauserverclient.server.request_factory as TSC_RF
 from tableauserverclient.helpers.strings import redact_xml
 import pytest
 import sys
 
 
-class WorkbookRequestTests(unittest.TestCase):
-    def test_embedded_extract_req(self):
-        include_all = True
-        embedded_datasources = None
-        xml_result = TSC_RF.RequestFactory.Workbook.embedded_extract_req(include_all, embedded_datasources)
-
-    def test_generate_xml(self):
-        workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
-        TSC_RF.RequestFactory.Workbook._generate_xml(workbook_item)
-
-    def test_generate_xml_invalid_connection(self):
-        workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
-        conn = TSC.ConnectionItem()
-        with self.assertRaises(ValueError):
-            request = TSC_RF.RequestFactory.Workbook._generate_xml(workbook_item, connections=[conn])
-
-    def test_generate_xml_invalid_connection_credentials(self):
-        workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
-        conn = TSC.ConnectionItem()
-        conn.server_address = "address"
-        creds = TSC.ConnectionCredentials("username", "password")
-        creds.name = None
-        conn.connection_credentials = creds
-        with self.assertRaises(ValueError):
-            request = TSC_RF.RequestFactory.Workbook._generate_xml(workbook_item, connections=[conn])
-
-    def test_generate_xml_valid_connection_credentials(self):
-        workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
-        conn = TSC.ConnectionItem()
-        conn.server_address = "address"
-        creds = TSC.ConnectionCredentials("username", "DELETEME")
-        conn.connection_credentials = creds
+def test_embedded_extract_req() -> None:
+    include_all = True
+    embedded_datasources = None
+    xml_result = TSC_RF.RequestFactory.Workbook.embedded_extract_req(include_all, embedded_datasources)
+
+
+def test_generate_xml() -> None:
+    workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
+    TSC_RF.RequestFactory.Workbook._generate_xml(workbook_item)
+
+
+def test_generate_xml_invalid_connection() -> None:
+    workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
+    conn = TSC.ConnectionItem()
+    with pytest.raises(ValueError):
         request = TSC_RF.RequestFactory.Workbook._generate_xml(workbook_item, connections=[conn])
-        assert request.find(b"DELETEME") > 0
-
-    def test_redact_passwords_in_xml(self):
-        if sys.version_info < (3, 7):
-            pytest.skip("Redaction is only implemented for 3.7+.")
-        workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
-        conn = TSC.ConnectionItem()
-        conn.server_address = "address"
-        creds = TSC.ConnectionCredentials("username", "DELETEME")
-        conn.connection_credentials = creds
+
+
+def test_generate_xml_invalid_connection_credentials() -> None:
+    workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
+    conn = TSC.ConnectionItem()
+    conn.server_address = "address"
+    creds = TSC.ConnectionCredentials("username", "password")
+    creds.name = None
+    conn.connection_credentials = creds
+    with pytest.raises(ValueError):
         request = TSC_RF.RequestFactory.Workbook._generate_xml(workbook_item, connections=[conn])
-        redacted = redact_xml(request)
-        assert request.find(b"DELETEME") > 0, request
-        assert redacted.find(b"DELETEME") == -1, redacted
+
+
+def test_generate_xml_valid_connection_credentials() -> None:
+    workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
+    conn = TSC.ConnectionItem()
+    conn.server_address = "address"
+    creds = TSC.ConnectionCredentials("username", "DELETEME")
+    conn.connection_credentials = creds
+    request = TSC_RF.RequestFactory.Workbook._generate_xml(workbook_item, connections=[conn])
+    assert request.find(b"DELETEME") > 0
+
+
+def test_redact_passwords_in_xml() -> None:
+    if sys.version_info < (3, 7):
+        pytest.skip("Redaction is only implemented for 3.7+.")
+    workbook_item: TSC.WorkbookItem = TSC.WorkbookItem("name", "project_id")
+    conn = TSC.ConnectionItem()
+    conn.server_address = "address"
+    creds = TSC.ConnectionCredentials("username", "DELETEME")
+    conn.connection_credentials = creds
+    request = TSC_RF.RequestFactory.Workbook._generate_xml(workbook_item, connections=[conn])
+    redacted = redact_xml(request)
+    assert request.find(b"DELETEME") > 0, request
+    assert redacted.find(b"DELETEME") == -1, redacted