From c6eea4719a5c46ca3146e2a1c7f685dd2284d887 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 16 Oct 2025 09:15:04 +0000 Subject: [PATCH 1/4] Initial plan From 6abf151acf27b53df7b6c91144b8230b177c14a1 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 16 Oct 2025 09:22:27 +0000 Subject: [PATCH 2/4] Add comprehensive test coverage for write_options.py and related models Co-authored-by: SoulPancake <70265851+SoulPancake@users.noreply.github.com> --- test/client/models/__init__.py | 11 + test/client/models/write_options_test.py | 329 +++++++++++++++++++++++ 2 files changed, 340 insertions(+) create mode 100644 test/client/models/__init__.py create mode 100644 test/client/models/write_options_test.py diff --git a/test/client/models/__init__.py b/test/client/models/__init__.py new file mode 100644 index 00000000..97b78a43 --- /dev/null +++ b/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. +""" diff --git a/test/client/models/write_options_test.py b/test/client/models/write_options_test.py new file mode 100644 index 00000000..3305474e --- /dev/null +++ b/test/client/models/write_options_test.py @@ -0,0 +1,329 @@ +""" +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 setUp(self): + pass + + def tearDown(self): + pass + + 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 setUp(self): + pass + + def tearDown(self): + pass + + 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 setUp(self): + pass + + def tearDown(self): + pass + + 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 setUp(self): + pass + + def tearDown(self): + pass + + 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") From f16cfb8a9dd6dbea0d8c8706249b23e380a83123 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 16 Oct 2025 09:27:00 +0000 Subject: [PATCH 3/4] Remove unnecessary empty setUp/tearDown methods from tests Co-authored-by: SoulPancake <70265851+SoulPancake@users.noreply.github.com> --- test/client/models/write_options_test.py | 24 ------------------------ 1 file changed, 24 deletions(-) diff --git a/test/client/models/write_options_test.py b/test/client/models/write_options_test.py index 3305474e..3d277789 100644 --- a/test/client/models/write_options_test.py +++ b/test/client/models/write_options_test.py @@ -24,12 +24,6 @@ class TestClientWriteOptions(unittest.TestCase): """Test for ClientWriteOptions""" - def setUp(self): - pass - - def tearDown(self): - pass - def test_client_write_options_init_with_no_params(self): """Test ClientWriteOptions initialization with no parameters""" options = ClientWriteOptions() @@ -118,12 +112,6 @@ def test_conflict_setter_none(self): class TestWriteTransactionOpts(unittest.TestCase): """Test for WriteTransactionOpts""" - def setUp(self): - pass - - def tearDown(self): - pass - def test_write_transaction_opts_init_defaults(self): """Test WriteTransactionOpts initialization with default values""" opts = WriteTransactionOpts() @@ -189,12 +177,6 @@ def test_max_parallel_requests_setter(self): class TestConflictOptions(unittest.TestCase): """Test for ConflictOptions""" - def setUp(self): - pass - - def tearDown(self): - pass - def test_conflict_options_init_defaults(self): """Test ConflictOptions initialization with default values""" opts = ConflictOptions() @@ -306,12 +288,6 @@ def test_on_missing_deletes_setter_none(self): class TestConflictEnums(unittest.TestCase): """Test for Conflict Enums""" - def setUp(self): - pass - - def tearDown(self): - pass - def test_client_write_request_on_duplicate_writes_error_value(self): """Test ClientWriteRequestOnDuplicateWrites.ERROR value""" self.assertEqual(ClientWriteRequestOnDuplicateWrites.ERROR.value, "error") From 4b5173170c5febfe66039e4971e03eedf4edbe89 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 16 Oct 2025 09:58:00 +0000 Subject: [PATCH 4/4] Add comprehensive tests for write_request.py and related models Co-authored-by: SoulPancake <70265851+SoulPancake@users.noreply.github.com> --- test/client/models/write_request_test.py | 192 +++++++++++++++++++++ test/models/__init__.py | 11 ++ test/models/write_request_deletes_test.py | 200 ++++++++++++++++++++++ test/models/write_request_writes_test.py | 200 ++++++++++++++++++++++ 4 files changed, 603 insertions(+) create mode 100644 test/client/models/write_request_test.py create mode 100644 test/models/__init__.py create mode 100644 test/models/write_request_deletes_test.py create mode 100644 test/models/write_request_writes_test.py diff --git a/test/client/models/write_request_test.py b/test/client/models/write_request_test.py new file mode 100644 index 00000000..0ead51b3 --- /dev/null +++ b/test/client/models/write_request_test.py @@ -0,0 +1,192 @@ +""" +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.tuple import ClientTuple +from openfga_sdk.client.models.write_request import ClientWriteRequest + + +class TestClientWriteRequest(unittest.TestCase): + """Test for ClientWriteRequest""" + + def test_client_write_request_init_with_no_params(self): + """Test ClientWriteRequest initialization with no parameters""" + request = ClientWriteRequest() + self.assertIsNone(request.writes) + self.assertIsNone(request.deletes) + self.assertIsNone(request.on_duplicate) + self.assertIsNone(request.on_missing) + + def test_client_write_request_init_with_writes(self): + """Test ClientWriteRequest initialization with writes""" + writes = [ClientTuple(user="user:alice", relation="viewer", object="doc:1")] + request = ClientWriteRequest(writes=writes) + self.assertEqual(request.writes, writes) + self.assertIsNone(request.deletes) + self.assertIsNone(request.on_duplicate) + self.assertIsNone(request.on_missing) + + def test_client_write_request_init_with_deletes(self): + """Test ClientWriteRequest initialization with deletes""" + deletes = [ClientTuple(user="user:bob", relation="editor", object="doc:2")] + request = ClientWriteRequest(deletes=deletes) + self.assertIsNone(request.writes) + self.assertEqual(request.deletes, deletes) + self.assertIsNone(request.on_duplicate) + self.assertIsNone(request.on_missing) + + def test_client_write_request_init_with_on_duplicate(self): + """Test ClientWriteRequest initialization with on_duplicate""" + request = ClientWriteRequest(on_duplicate="ignore") + self.assertIsNone(request.writes) + self.assertIsNone(request.deletes) + self.assertEqual(request.on_duplicate, "ignore") + self.assertIsNone(request.on_missing) + + def test_client_write_request_init_with_on_missing(self): + """Test ClientWriteRequest initialization with on_missing""" + request = ClientWriteRequest(on_missing="ignore") + self.assertIsNone(request.writes) + self.assertIsNone(request.deletes) + self.assertIsNone(request.on_duplicate) + self.assertEqual(request.on_missing, "ignore") + + def test_client_write_request_init_with_all_params(self): + """Test ClientWriteRequest initialization with all parameters""" + writes = [ClientTuple(user="user:alice", relation="viewer", object="doc:1")] + deletes = [ClientTuple(user="user:bob", relation="editor", object="doc:2")] + request = ClientWriteRequest( + writes=writes, deletes=deletes, on_duplicate="error", on_missing="error" + ) + self.assertEqual(request.writes, writes) + self.assertEqual(request.deletes, deletes) + self.assertEqual(request.on_duplicate, "error") + self.assertEqual(request.on_missing, "error") + + def test_writes_setter(self): + """Test writes setter""" + request = ClientWriteRequest() + writes = [ClientTuple(user="user:charlie", relation="owner", object="doc:3")] + request.writes = writes + self.assertEqual(request.writes, writes) + + def test_writes_setter_none(self): + """Test writes setter with None""" + writes = [ClientTuple(user="user:alice", relation="viewer", object="doc:1")] + request = ClientWriteRequest(writes=writes) + request.writes = None + self.assertIsNone(request.writes) + + def test_deletes_setter(self): + """Test deletes setter""" + request = ClientWriteRequest() + deletes = [ClientTuple(user="user:dave", relation="viewer", object="doc:4")] + request.deletes = deletes + self.assertEqual(request.deletes, deletes) + + def test_deletes_setter_none(self): + """Test deletes setter with None""" + deletes = [ClientTuple(user="user:bob", relation="editor", object="doc:2")] + request = ClientWriteRequest(deletes=deletes) + request.deletes = None + self.assertIsNone(request.deletes) + + def test_on_duplicate_setter(self): + """Test on_duplicate setter""" + request = ClientWriteRequest() + request.on_duplicate = "ignore" + self.assertEqual(request.on_duplicate, "ignore") + + def test_on_duplicate_setter_none(self): + """Test on_duplicate setter with None""" + request = ClientWriteRequest(on_duplicate="error") + request.on_duplicate = None + self.assertIsNone(request.on_duplicate) + + def test_on_missing_setter(self): + """Test on_missing setter""" + request = ClientWriteRequest() + request.on_missing = "ignore" + self.assertEqual(request.on_missing, "ignore") + + def test_on_missing_setter_none(self): + """Test on_missing setter with None""" + request = ClientWriteRequest(on_missing="error") + request.on_missing = None + self.assertIsNone(request.on_missing) + + def test_writes_tuple_keys_with_none_writes(self): + """Test writes_tuple_keys property with None writes""" + request = ClientWriteRequest() + self.assertIsNone(request.writes_tuple_keys) + + def test_writes_tuple_keys_with_empty_writes(self): + """Test writes_tuple_keys property with empty writes list""" + request = ClientWriteRequest(writes=[]) + result = request.writes_tuple_keys + self.assertIsNotNone(result) + self.assertEqual(result.tuple_keys, []) + + def test_writes_tuple_keys_with_writes(self): + """Test writes_tuple_keys property with writes""" + writes = [ClientTuple(user="user:alice", relation="viewer", object="doc:1")] + request = ClientWriteRequest(writes=writes, on_duplicate="error") + result = request.writes_tuple_keys + self.assertIsNotNone(result) + self.assertEqual(len(result.tuple_keys), 1) + self.assertEqual(result.on_duplicate, "error") + + def test_writes_tuple_keys_with_on_duplicate(self): + """Test writes_tuple_keys property includes on_duplicate""" + writes = [ + ClientTuple(user="user:alice", relation="viewer", object="doc:1"), + ClientTuple(user="user:bob", relation="editor", object="doc:2"), + ] + request = ClientWriteRequest(writes=writes, on_duplicate="ignore") + result = request.writes_tuple_keys + self.assertIsNotNone(result) + self.assertEqual(len(result.tuple_keys), 2) + self.assertEqual(result.on_duplicate, "ignore") + + def test_deletes_tuple_keys_with_none_deletes(self): + """Test deletes_tuple_keys property with None deletes""" + request = ClientWriteRequest() + self.assertIsNone(request.deletes_tuple_keys) + + def test_deletes_tuple_keys_with_empty_deletes(self): + """Test deletes_tuple_keys property with empty deletes list""" + request = ClientWriteRequest(deletes=[]) + result = request.deletes_tuple_keys + self.assertIsNotNone(result) + self.assertEqual(result.tuple_keys, []) + + def test_deletes_tuple_keys_with_deletes(self): + """Test deletes_tuple_keys property with deletes""" + deletes = [ClientTuple(user="user:bob", relation="editor", object="doc:2")] + request = ClientWriteRequest(deletes=deletes, on_missing="error") + result = request.deletes_tuple_keys + self.assertIsNotNone(result) + self.assertEqual(len(result.tuple_keys), 1) + self.assertEqual(result.on_missing, "error") + + def test_deletes_tuple_keys_with_on_missing(self): + """Test deletes_tuple_keys property includes on_missing""" + deletes = [ + ClientTuple(user="user:charlie", relation="owner", object="doc:3"), + ClientTuple(user="user:dave", relation="viewer", object="doc:4"), + ] + request = ClientWriteRequest(deletes=deletes, on_missing="ignore") + result = request.deletes_tuple_keys + self.assertIsNotNone(result) + self.assertEqual(len(result.tuple_keys), 2) + self.assertEqual(result.on_missing, "ignore") diff --git a/test/models/__init__.py b/test/models/__init__.py new file mode 100644 index 00000000..97b78a43 --- /dev/null +++ b/test/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. +""" diff --git a/test/models/write_request_deletes_test.py b/test/models/write_request_deletes_test.py new file mode 100644 index 00000000..9b95520f --- /dev/null +++ b/test/models/write_request_deletes_test.py @@ -0,0 +1,200 @@ +""" +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 unittest.mock import Mock + +from openfga_sdk.configuration import Configuration +from openfga_sdk.models.write_request_deletes import WriteRequestDeletes + + +class TestWriteRequestDeletes(unittest.TestCase): + """Test for WriteRequestDeletes""" + + def test_write_request_deletes_init_defaults(self): + """Test WriteRequestDeletes initialization with defaults""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + self.assertEqual(deletes.tuple_keys, tuple_keys) + self.assertEqual(deletes.on_missing, "error") + + def test_write_request_deletes_init_with_on_missing_error(self): + """Test WriteRequestDeletes initialization with on_missing='error'""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys, on_missing="error") + self.assertEqual(deletes.tuple_keys, tuple_keys) + self.assertEqual(deletes.on_missing, "error") + + def test_write_request_deletes_init_with_on_missing_ignore(self): + """Test WriteRequestDeletes initialization with on_missing='ignore'""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys, on_missing="ignore") + self.assertEqual(deletes.tuple_keys, tuple_keys) + self.assertEqual(deletes.on_missing, "ignore") + + def test_write_request_deletes_init_with_none_on_missing(self): + """Test WriteRequestDeletes initialization with on_missing=None""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys, on_missing=None) + self.assertEqual(deletes.tuple_keys, tuple_keys) + self.assertIsNone(deletes.on_missing) + + def test_write_request_deletes_init_with_local_vars_configuration(self): + """Test WriteRequestDeletes initialization with custom configuration""" + config = Configuration() + tuple_keys = [Mock()] + deletes = WriteRequestDeletes( + tuple_keys=tuple_keys, local_vars_configuration=config + ) + self.assertEqual(deletes.tuple_keys, tuple_keys) + self.assertEqual(deletes.local_vars_configuration, config) + + def test_tuple_keys_setter(self): + """Test tuple_keys setter""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + new_tuple_keys = [Mock(), Mock()] + deletes.tuple_keys = new_tuple_keys + self.assertEqual(deletes.tuple_keys, new_tuple_keys) + + def test_tuple_keys_setter_raises_error_for_none(self): + """Test tuple_keys setter raises ValueError for None""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + with self.assertRaises(ValueError) as context: + deletes.tuple_keys = None + self.assertIn("Invalid value for `tuple_keys`", str(context.exception)) + + def test_on_missing_setter_error(self): + """Test on_missing setter with 'error'""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + deletes.on_missing = "error" + self.assertEqual(deletes.on_missing, "error") + + def test_on_missing_setter_ignore(self): + """Test on_missing setter with 'ignore'""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + deletes.on_missing = "ignore" + self.assertEqual(deletes.on_missing, "ignore") + + def test_on_missing_setter_raises_error_for_invalid_value(self): + """Test on_missing setter raises ValueError for invalid value""" + tuple_keys = [Mock()] + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + with self.assertRaises(ValueError) as context: + deletes.on_missing = "invalid" + self.assertIn("Invalid value for `on_missing`", str(context.exception)) + + def test_to_dict_basic(self): + """Test to_dict method with basic data""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + deletes = WriteRequestDeletes(tuple_keys=tuple_keys, on_missing="error") + result = deletes.to_dict() + self.assertIn("tuple_keys", result) + self.assertIn("on_missing", result) + self.assertEqual(result["on_missing"], "error") + + def test_to_dict_serialize(self): + """Test to_dict method with serialize=True""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + deletes = WriteRequestDeletes(tuple_keys=tuple_keys, on_missing="ignore") + result = deletes.to_dict(serialize=True) + self.assertIn("tuple_keys", result) + self.assertIn("on_missing", result) + self.assertEqual(result["on_missing"], "ignore") + + def test_to_str(self): + """Test to_str method""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + result = deletes.to_str() + self.assertIsInstance(result, str) + + def test_repr(self): + """Test __repr__ method""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + result = repr(deletes) + self.assertIsInstance(result, str) + + def test_eq_same_object(self): + """Test __eq__ with same object""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + deletes = WriteRequestDeletes(tuple_keys=tuple_keys, on_missing="error") + self.assertEqual(deletes, deletes) + + def test_eq_equal_objects(self): + """Test __eq__ with equal objects""" + tuple_keys1 = [Mock()] + tuple_keys1[0].to_dict = Mock(return_value={"key": "value"}) + deletes1 = WriteRequestDeletes(tuple_keys=tuple_keys1, on_missing="error") + + tuple_keys2 = [Mock()] + tuple_keys2[0].to_dict = Mock(return_value={"key": "value"}) + deletes2 = WriteRequestDeletes(tuple_keys=tuple_keys2, on_missing="error") + + self.assertEqual(deletes1, deletes2) + + def test_eq_different_objects(self): + """Test __eq__ with different objects""" + tuple_keys1 = [Mock()] + tuple_keys1[0].to_dict = Mock(return_value={"key": "value1"}) + deletes1 = WriteRequestDeletes(tuple_keys=tuple_keys1, on_missing="error") + + tuple_keys2 = [Mock()] + tuple_keys2[0].to_dict = Mock(return_value={"key": "value2"}) + deletes2 = WriteRequestDeletes(tuple_keys=tuple_keys2, on_missing="ignore") + + self.assertNotEqual(deletes1, deletes2) + + def test_eq_with_non_write_request_deletes(self): + """Test __eq__ with non-WriteRequestDeletes object""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + self.assertNotEqual(deletes, "not a WriteRequestDeletes") + + def test_ne_different_objects(self): + """Test __ne__ with different objects""" + tuple_keys1 = [Mock()] + tuple_keys1[0].to_dict = Mock(return_value={"key": "value1"}) + deletes1 = WriteRequestDeletes(tuple_keys=tuple_keys1, on_missing="error") + + tuple_keys2 = [Mock()] + tuple_keys2[0].to_dict = Mock(return_value={"key": "value2"}) + deletes2 = WriteRequestDeletes(tuple_keys=tuple_keys2, on_missing="ignore") + + self.assertTrue(deletes1 != deletes2) + + def test_ne_with_non_write_request_deletes(self): + """Test __ne__ with non-WriteRequestDeletes object""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + deletes = WriteRequestDeletes(tuple_keys=tuple_keys) + self.assertTrue(deletes != "not a WriteRequestDeletes") + + def test_openapi_types(self): + """Test openapi_types class attribute""" + self.assertIn("tuple_keys", WriteRequestDeletes.openapi_types) + self.assertIn("on_missing", WriteRequestDeletes.openapi_types) + + def test_attribute_map(self): + """Test attribute_map class attribute""" + self.assertIn("tuple_keys", WriteRequestDeletes.attribute_map) + self.assertIn("on_missing", WriteRequestDeletes.attribute_map) diff --git a/test/models/write_request_writes_test.py b/test/models/write_request_writes_test.py new file mode 100644 index 00000000..9d269c18 --- /dev/null +++ b/test/models/write_request_writes_test.py @@ -0,0 +1,200 @@ +""" +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 unittest.mock import Mock + +from openfga_sdk.configuration import Configuration +from openfga_sdk.models.write_request_writes import WriteRequestWrites + + +class TestWriteRequestWrites(unittest.TestCase): + """Test for WriteRequestWrites""" + + def test_write_request_writes_init_defaults(self): + """Test WriteRequestWrites initialization with defaults""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys) + self.assertEqual(writes.tuple_keys, tuple_keys) + self.assertEqual(writes.on_duplicate, "error") + + def test_write_request_writes_init_with_on_duplicate_error(self): + """Test WriteRequestWrites initialization with on_duplicate='error'""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys, on_duplicate="error") + self.assertEqual(writes.tuple_keys, tuple_keys) + self.assertEqual(writes.on_duplicate, "error") + + def test_write_request_writes_init_with_on_duplicate_ignore(self): + """Test WriteRequestWrites initialization with on_duplicate='ignore'""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys, on_duplicate="ignore") + self.assertEqual(writes.tuple_keys, tuple_keys) + self.assertEqual(writes.on_duplicate, "ignore") + + def test_write_request_writes_init_with_none_on_duplicate(self): + """Test WriteRequestWrites initialization with on_duplicate=None""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys, on_duplicate=None) + self.assertEqual(writes.tuple_keys, tuple_keys) + self.assertIsNone(writes.on_duplicate) + + def test_write_request_writes_init_with_local_vars_configuration(self): + """Test WriteRequestWrites initialization with custom configuration""" + config = Configuration() + tuple_keys = [Mock()] + writes = WriteRequestWrites( + tuple_keys=tuple_keys, local_vars_configuration=config + ) + self.assertEqual(writes.tuple_keys, tuple_keys) + self.assertEqual(writes.local_vars_configuration, config) + + def test_tuple_keys_setter(self): + """Test tuple_keys setter""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys) + new_tuple_keys = [Mock(), Mock()] + writes.tuple_keys = new_tuple_keys + self.assertEqual(writes.tuple_keys, new_tuple_keys) + + def test_tuple_keys_setter_raises_error_for_none(self): + """Test tuple_keys setter raises ValueError for None""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys) + with self.assertRaises(ValueError) as context: + writes.tuple_keys = None + self.assertIn("Invalid value for `tuple_keys`", str(context.exception)) + + def test_on_duplicate_setter_error(self): + """Test on_duplicate setter with 'error'""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys) + writes.on_duplicate = "error" + self.assertEqual(writes.on_duplicate, "error") + + def test_on_duplicate_setter_ignore(self): + """Test on_duplicate setter with 'ignore'""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys) + writes.on_duplicate = "ignore" + self.assertEqual(writes.on_duplicate, "ignore") + + def test_on_duplicate_setter_raises_error_for_invalid_value(self): + """Test on_duplicate setter raises ValueError for invalid value""" + tuple_keys = [Mock()] + writes = WriteRequestWrites(tuple_keys=tuple_keys) + with self.assertRaises(ValueError) as context: + writes.on_duplicate = "invalid" + self.assertIn("Invalid value for `on_duplicate`", str(context.exception)) + + def test_to_dict_basic(self): + """Test to_dict method with basic data""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + writes = WriteRequestWrites(tuple_keys=tuple_keys, on_duplicate="error") + result = writes.to_dict() + self.assertIn("tuple_keys", result) + self.assertIn("on_duplicate", result) + self.assertEqual(result["on_duplicate"], "error") + + def test_to_dict_serialize(self): + """Test to_dict method with serialize=True""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + writes = WriteRequestWrites(tuple_keys=tuple_keys, on_duplicate="ignore") + result = writes.to_dict(serialize=True) + self.assertIn("tuple_keys", result) + self.assertIn("on_duplicate", result) + self.assertEqual(result["on_duplicate"], "ignore") + + def test_to_str(self): + """Test to_str method""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + writes = WriteRequestWrites(tuple_keys=tuple_keys) + result = writes.to_str() + self.assertIsInstance(result, str) + + def test_repr(self): + """Test __repr__ method""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + writes = WriteRequestWrites(tuple_keys=tuple_keys) + result = repr(writes) + self.assertIsInstance(result, str) + + def test_eq_same_object(self): + """Test __eq__ with same object""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + writes = WriteRequestWrites(tuple_keys=tuple_keys, on_duplicate="error") + self.assertEqual(writes, writes) + + def test_eq_equal_objects(self): + """Test __eq__ with equal objects""" + tuple_keys1 = [Mock()] + tuple_keys1[0].to_dict = Mock(return_value={"key": "value"}) + writes1 = WriteRequestWrites(tuple_keys=tuple_keys1, on_duplicate="error") + + tuple_keys2 = [Mock()] + tuple_keys2[0].to_dict = Mock(return_value={"key": "value"}) + writes2 = WriteRequestWrites(tuple_keys=tuple_keys2, on_duplicate="error") + + self.assertEqual(writes1, writes2) + + def test_eq_different_objects(self): + """Test __eq__ with different objects""" + tuple_keys1 = [Mock()] + tuple_keys1[0].to_dict = Mock(return_value={"key": "value1"}) + writes1 = WriteRequestWrites(tuple_keys=tuple_keys1, on_duplicate="error") + + tuple_keys2 = [Mock()] + tuple_keys2[0].to_dict = Mock(return_value={"key": "value2"}) + writes2 = WriteRequestWrites(tuple_keys=tuple_keys2, on_duplicate="ignore") + + self.assertNotEqual(writes1, writes2) + + def test_eq_with_non_write_request_writes(self): + """Test __eq__ with non-WriteRequestWrites object""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + writes = WriteRequestWrites(tuple_keys=tuple_keys) + self.assertNotEqual(writes, "not a WriteRequestWrites") + + def test_ne_different_objects(self): + """Test __ne__ with different objects""" + tuple_keys1 = [Mock()] + tuple_keys1[0].to_dict = Mock(return_value={"key": "value1"}) + writes1 = WriteRequestWrites(tuple_keys=tuple_keys1, on_duplicate="error") + + tuple_keys2 = [Mock()] + tuple_keys2[0].to_dict = Mock(return_value={"key": "value2"}) + writes2 = WriteRequestWrites(tuple_keys=tuple_keys2, on_duplicate="ignore") + + self.assertTrue(writes1 != writes2) + + def test_ne_with_non_write_request_writes(self): + """Test __ne__ with non-WriteRequestWrites object""" + tuple_keys = [Mock()] + tuple_keys[0].to_dict = Mock(return_value={"key": "value"}) + writes = WriteRequestWrites(tuple_keys=tuple_keys) + self.assertTrue(writes != "not a WriteRequestWrites") + + def test_openapi_types(self): + """Test openapi_types class attribute""" + self.assertIn("tuple_keys", WriteRequestWrites.openapi_types) + self.assertIn("on_duplicate", WriteRequestWrites.openapi_types) + + def test_attribute_map(self): + """Test attribute_map class attribute""" + self.assertIn("tuple_keys", WriteRequestWrites.attribute_map) + self.assertIn("on_duplicate", WriteRequestWrites.attribute_map)