feat: gen extensive test coverage

test/client/models/__init__.py

@@ -0,0 +1,11 @@
+"""
+Python SDK for OpenFGA
+
+API version: 1.x
+Website: https://openfga.dev
+Documentation: https://openfga.dev/docs
+Support: https://openfga.dev/community
+License: [Apache-2.0](https://github.com/openfga/python-sdk/blob/main/LICENSE)
+
+NOTE: This file was auto generated by OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+"""

test/client/models/write_options_test.py

@@ -0,0 +1,305 @@
+"""
+Python SDK for OpenFGA
+
+API version: 1.x
+Website: https://openfga.dev
+Documentation: https://openfga.dev/docs
+Support: https://openfga.dev/community
+License: [Apache-2.0](https://github.com/openfga/python-sdk/blob/main/LICENSE)
+
+NOTE: This file was auto generated by OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+"""
+
+import unittest
+
+from openfga_sdk.client.models.write_conflict_opts import (
+    ClientWriteRequestOnDuplicateWrites,
+    ClientWriteRequestOnMissingDeletes,
+    ConflictOptions,
+)
+from openfga_sdk.client.models.write_options import ClientWriteOptions
+from openfga_sdk.client.models.write_transaction_opts import WriteTransactionOpts
+
+
+class TestClientWriteOptions(unittest.TestCase):
+    """Test for ClientWriteOptions"""
+
+    def test_client_write_options_init_with_no_params(self):
+        """Test ClientWriteOptions initialization with no parameters"""
+        options = ClientWriteOptions()
+        self.assertIsNone(options.authorization_model_id)
+        self.assertIsNone(options.transaction)
+        self.assertIsNone(options.conflict)
+
+    def test_client_write_options_init_with_authorization_model_id(self):
+        """Test ClientWriteOptions initialization with authorization_model_id"""
+        model_id = "01HVMMBCMGZNT3SED4Z17ECXCA"
+        options = ClientWriteOptions(authorization_model_id=model_id)
+        self.assertEqual(options.authorization_model_id, model_id)
+        self.assertIsNone(options.transaction)
+        self.assertIsNone(options.conflict)
+
+    def test_client_write_options_init_with_transaction(self):
+        """Test ClientWriteOptions initialization with transaction"""
+        transaction = WriteTransactionOpts()
+        options = ClientWriteOptions(transaction=transaction)
+        self.assertIsNone(options.authorization_model_id)
+        self.assertEqual(options.transaction, transaction)
+        self.assertIsNone(options.conflict)
+
+    def test_client_write_options_init_with_conflict(self):
+        """Test ClientWriteOptions initialization with conflict"""
+        conflict = ConflictOptions()
+        options = ClientWriteOptions(conflict=conflict)
+        self.assertIsNone(options.authorization_model_id)
+        self.assertIsNone(options.transaction)
+        self.assertEqual(options.conflict, conflict)
+
+    def test_client_write_options_init_with_all_params(self):
+        """Test ClientWriteOptions initialization with all parameters"""
+        model_id = "01HVMMBCMGZNT3SED4Z17ECXCA"
+        transaction = WriteTransactionOpts()
+        conflict = ConflictOptions()
+        options = ClientWriteOptions(
+            authorization_model_id=model_id, transaction=transaction, conflict=conflict
+        )
+        self.assertEqual(options.authorization_model_id, model_id)
+        self.assertEqual(options.transaction, transaction)
+        self.assertEqual(options.conflict, conflict)
+
+    def test_authorization_model_id_setter(self):
+        """Test authorization_model_id setter"""
+        options = ClientWriteOptions()
+        model_id = "01HVMMBCMGZNT3SED4Z17ECXCA"
+        options.authorization_model_id = model_id
+        self.assertEqual(options.authorization_model_id, model_id)
+
+    def test_authorization_model_id_setter_none(self):
+        """Test authorization_model_id setter with None"""
+        options = ClientWriteOptions(authorization_model_id="01HVMMBCMGZNT3SED4Z17ECXCA")
+        options.authorization_model_id = None
+        self.assertIsNone(options.authorization_model_id)
+
+    def test_transaction_setter(self):
+        """Test transaction setter"""
+        options = ClientWriteOptions()
+        transaction = WriteTransactionOpts(disabled=True, max_per_chunk=5)
+        options.transaction = transaction
+        self.assertEqual(options.transaction, transaction)
+
+    def test_transaction_setter_none(self):
+        """Test transaction setter with None"""
+        options = ClientWriteOptions(transaction=WriteTransactionOpts())
+        options.transaction = None
+        self.assertIsNone(options.transaction)
+
+    def test_conflict_setter(self):
+        """Test conflict setter"""
+        options = ClientWriteOptions()
+        conflict = ConflictOptions(
+            on_duplicate_writes=ClientWriteRequestOnDuplicateWrites.ERROR
+        )
+        options.conflict = conflict
+        self.assertEqual(options.conflict, conflict)
+
+    def test_conflict_setter_none(self):
+        """Test conflict setter with None"""
+        options = ClientWriteOptions(conflict=ConflictOptions())
+        options.conflict = None
+        self.assertIsNone(options.conflict)
+
+
+class TestWriteTransactionOpts(unittest.TestCase):
+    """Test for WriteTransactionOpts"""
+
+    def test_write_transaction_opts_init_defaults(self):
+        """Test WriteTransactionOpts initialization with default values"""
+        opts = WriteTransactionOpts()
+        self.assertEqual(opts.disabled, False)
+        self.assertEqual(opts.max_per_chunk, 1)
+        self.assertEqual(opts.max_parallel_requests, 10)
+
+    def test_write_transaction_opts_init_with_disabled(self):
+        """Test WriteTransactionOpts initialization with disabled=True"""
+        opts = WriteTransactionOpts(disabled=True)
+        self.assertEqual(opts.disabled, True)
+        self.assertEqual(opts.max_per_chunk, 1)
+        self.assertEqual(opts.max_parallel_requests, 10)
+
+    def test_write_transaction_opts_init_with_max_per_chunk(self):
+        """Test WriteTransactionOpts initialization with custom max_per_chunk"""
+        opts = WriteTransactionOpts(max_per_chunk=5)
+        self.assertEqual(opts.disabled, False)
+        self.assertEqual(opts.max_per_chunk, 5)
+        self.assertEqual(opts.max_parallel_requests, 10)
+
+    def test_write_transaction_opts_init_with_max_parallel_requests(self):
+        """Test WriteTransactionOpts initialization with custom max_parallel_requests"""
+        opts = WriteTransactionOpts(max_parallel_requests=20)
+        self.assertEqual(opts.disabled, False)
+        self.assertEqual(opts.max_per_chunk, 1)
+        self.assertEqual(opts.max_parallel_requests, 20)
+
+    def test_write_transaction_opts_init_with_all_params(self):
+        """Test WriteTransactionOpts initialization with all parameters"""
+        opts = WriteTransactionOpts(
+            disabled=True, max_per_chunk=15, max_parallel_requests=25
+        )
+        self.assertEqual(opts.disabled, True)
+        self.assertEqual(opts.max_per_chunk, 15)
+        self.assertEqual(opts.max_parallel_requests, 25)
+
+    def test_disabled_setter(self):
+        """Test disabled setter"""
+        opts = WriteTransactionOpts()
+        opts.disabled = True
+        self.assertEqual(opts.disabled, True)
+
+    def test_disabled_setter_false(self):
+        """Test disabled setter with False"""
+        opts = WriteTransactionOpts(disabled=True)
+        opts.disabled = False
+        self.assertEqual(opts.disabled, False)
+
+    def test_max_per_chunk_setter(self):
+        """Test max_per_chunk setter"""
+        opts = WriteTransactionOpts()
+        opts.max_per_chunk = 10
+        self.assertEqual(opts.max_per_chunk, 10)
+
+    def test_max_parallel_requests_setter(self):
+        """Test max_parallel_requests setter"""
+        opts = WriteTransactionOpts()
+        opts.max_parallel_requests = 30
+        self.assertEqual(opts.max_parallel_requests, 30)
+
+
+class TestConflictOptions(unittest.TestCase):
+    """Test for ConflictOptions"""
+
+    def test_conflict_options_init_defaults(self):
+        """Test ConflictOptions initialization with default values"""
+        opts = ConflictOptions()
+        self.assertIsNone(opts.on_duplicate_writes)
+        self.assertIsNone(opts.on_missing_deletes)
+
+    def test_conflict_options_init_with_on_duplicate_writes_error(self):
+        """Test ConflictOptions initialization with on_duplicate_writes=ERROR"""
+        opts = ConflictOptions(
+            on_duplicate_writes=ClientWriteRequestOnDuplicateWrites.ERROR
+        )
+        self.assertEqual(
+            opts.on_duplicate_writes, ClientWriteRequestOnDuplicateWrites.ERROR
+        )
+        self.assertIsNone(opts.on_missing_deletes)
+
+    def test_conflict_options_init_with_on_duplicate_writes_ignore(self):
+        """Test ConflictOptions initialization with on_duplicate_writes=IGNORE"""
+        opts = ConflictOptions(
+            on_duplicate_writes=ClientWriteRequestOnDuplicateWrites.IGNORE
+        )
+        self.assertEqual(
+            opts.on_duplicate_writes, ClientWriteRequestOnDuplicateWrites.IGNORE
+        )
+        self.assertIsNone(opts.on_missing_deletes)
+
+    def test_conflict_options_init_with_on_missing_deletes_error(self):
+        """Test ConflictOptions initialization with on_missing_deletes=ERROR"""
+        opts = ConflictOptions(
+            on_missing_deletes=ClientWriteRequestOnMissingDeletes.ERROR
+        )
+        self.assertIsNone(opts.on_duplicate_writes)
+        self.assertEqual(
+            opts.on_missing_deletes, ClientWriteRequestOnMissingDeletes.ERROR
+        )
+
+    def test_conflict_options_init_with_on_missing_deletes_ignore(self):
+        """Test ConflictOptions initialization with on_missing_deletes=IGNORE"""
+        opts = ConflictOptions(
+            on_missing_deletes=ClientWriteRequestOnMissingDeletes.IGNORE
+        )
+        self.assertIsNone(opts.on_duplicate_writes)
+        self.assertEqual(
+            opts.on_missing_deletes, ClientWriteRequestOnMissingDeletes.IGNORE
+        )
+
+    def test_conflict_options_init_with_all_params(self):
+        """Test ConflictOptions initialization with all parameters"""
+        opts = ConflictOptions(
+            on_duplicate_writes=ClientWriteRequestOnDuplicateWrites.ERROR,
+            on_missing_deletes=ClientWriteRequestOnMissingDeletes.IGNORE,
+        )
+        self.assertEqual(
+            opts.on_duplicate_writes, ClientWriteRequestOnDuplicateWrites.ERROR
+        )
+        self.assertEqual(
+            opts.on_missing_deletes, ClientWriteRequestOnMissingDeletes.IGNORE
+        )
+
+    def test_on_duplicate_writes_setter_error(self):
+        """Test on_duplicate_writes setter with ERROR"""
+        opts = ConflictOptions()
+        opts.on_duplicate_writes = ClientWriteRequestOnDuplicateWrites.ERROR
+        self.assertEqual(
+            opts.on_duplicate_writes, ClientWriteRequestOnDuplicateWrites.ERROR
+        )
+
+    def test_on_duplicate_writes_setter_ignore(self):
+        """Test on_duplicate_writes setter with IGNORE"""
+        opts = ConflictOptions()
+        opts.on_duplicate_writes = ClientWriteRequestOnDuplicateWrites.IGNORE
+        self.assertEqual(
+            opts.on_duplicate_writes, ClientWriteRequestOnDuplicateWrites.IGNORE
+        )
+
+    def test_on_duplicate_writes_setter_none(self):
+        """Test on_duplicate_writes setter with None"""
+        opts = ConflictOptions(
+            on_duplicate_writes=ClientWriteRequestOnDuplicateWrites.ERROR
+        )
+        opts.on_duplicate_writes = None
+        self.assertIsNone(opts.on_duplicate_writes)
+
+    def test_on_missing_deletes_setter_error(self):
+        """Test on_missing_deletes setter with ERROR"""
+        opts = ConflictOptions()
+        opts.on_missing_deletes = ClientWriteRequestOnMissingDeletes.ERROR
+        self.assertEqual(
+            opts.on_missing_deletes, ClientWriteRequestOnMissingDeletes.ERROR
+        )
+
+    def test_on_missing_deletes_setter_ignore(self):
+        """Test on_missing_deletes setter with IGNORE"""
+        opts = ConflictOptions()
+        opts.on_missing_deletes = ClientWriteRequestOnMissingDeletes.IGNORE
+        self.assertEqual(
+            opts.on_missing_deletes, ClientWriteRequestOnMissingDeletes.IGNORE
+        )
+
+    def test_on_missing_deletes_setter_none(self):
+        """Test on_missing_deletes setter with None"""
+        opts = ConflictOptions(
+            on_missing_deletes=ClientWriteRequestOnMissingDeletes.ERROR
+        )
+        opts.on_missing_deletes = None
+        self.assertIsNone(opts.on_missing_deletes)
+
+
+class TestConflictEnums(unittest.TestCase):
+    """Test for Conflict Enums"""
+
+    def test_client_write_request_on_duplicate_writes_error_value(self):
+        """Test ClientWriteRequestOnDuplicateWrites.ERROR value"""
+        self.assertEqual(ClientWriteRequestOnDuplicateWrites.ERROR.value, "error")
+
+    def test_client_write_request_on_duplicate_writes_ignore_value(self):
+        """Test ClientWriteRequestOnDuplicateWrites.IGNORE value"""
+        self.assertEqual(ClientWriteRequestOnDuplicateWrites.IGNORE.value, "ignore")
+
+    def test_client_write_request_on_missing_deletes_error_value(self):
+        """Test ClientWriteRequestOnMissingDeletes.ERROR value"""
+        self.assertEqual(ClientWriteRequestOnMissingDeletes.ERROR.value, "error")
+
+    def test_client_write_request_on_missing_deletes_ignore_value(self):
+        """Test ClientWriteRequestOnMissingDeletes.IGNORE value"""
+        self.assertEqual(ClientWriteRequestOnMissingDeletes.IGNORE.value, "ignore")