@@ -0,0 +1,121 @@
+
+import ipaddress
+import json
+import pytest
+from psycopg.types.json import Jsonb
+
+from rhosocial.activerecord.backend.impl.postgres.adapters import PostgresJSONBAdapter, \
+    PostgresNetworkAddressAdapter
+
+
+# Tests for PostgresJSONBAdapter
+def test_jsonb_adapter_supported_types():
+    adapter = PostgresJSONBAdapter()
+    supported = adapter.supported_types
+    assert supported[dict] == [Jsonb]
+    assert supported[list] == [Jsonb]
+
+
+def test_jsonb_to_database():
+    adapter = PostgresJSONBAdapter()
+    my_dict = {"a": 1, "b": [2, 3]}
+    my_list = [1, "test", {"c": 4}]
+
+    # Test with dict
+    result_dict = adapter.to_database(my_dict, dict)
+    assert isinstance(result_dict, Jsonb)
+    assert result_dict.obj == my_dict
+
+    # Test with list
+    result_list = adapter.to_database(my_list, list)
+    assert isinstance(result_list, Jsonb)
+    assert result_list.obj == my_list
+
+    # Test with None
+    assert adapter.to_database(None, dict) is None
+
+
+def test_jsonb_from_database():
+    adapter = PostgresJSONBAdapter()
+    my_dict = {"key": "value"}
+    my_list = ["item1", "item2"]
+    json_string = '{"key": "value_from_string"}'
+
+    # Test with value already being a dict or list
+    assert adapter.from_database(my_dict, dict) is my_dict
+    assert adapter.from_database(my_list, list) is my_list
+
+    # Test with a JSON string representation
+    result = adapter.from_database(json_string, dict)
+    assert isinstance(result, dict)
+    assert result["key"] == "value_from_string"
+
+    # Test with None
+    assert adapter.from_database(None, dict) is None
+
+
+# Tests for PostgresNetworkAddressAdapter
+def test_network_adapter_supported_types():
+    adapter = PostgresNetworkAddressAdapter()
+    supported = adapter.supported_types
+    assert supported[ipaddress.IPv4Address] == [str]
+    assert supported[ipaddress.IPv6Address] == [str]
+    assert supported[ipaddress.IPv4Network] == [str]
+    assert supported[ipaddress.IPv6Network] == [str]
+
+
+def test_network_adapter_supported_types_no_ipaddress(mocker):
+    """Test that it returns empty dict if ipaddress module is missing."""
+    mocker.patch('builtins.__import__', side_effect=ImportError)
+    adapter = PostgresNetworkAddressAdapter()
+    assert adapter.supported_types == {}
+
+
+@pytest.mark.parametrize("ip_obj, expected_str", [
+    (ipaddress.ip_address("192.168.1.1"), "192.168.1.1"),
+    (ipaddress.ip_address("2001:db8::1"), "2001:db8::1"),
+    (ipaddress.ip_network("192.168.0.0/24"), "192.168.0.0/24"),
+    (ipaddress.ip_network("2001:db8::/32"), "2001:db8::/32"),
+])
+def test_network_to_database(ip_obj, expected_str):
+    adapter = PostgresNetworkAddressAdapter()
+    result = adapter.to_database(ip_obj, type(ip_obj))
+    assert result == expected_str
+
+
+def test_network_to_database_none():
+    adapter = PostgresNetworkAddressAdapter()
+    assert adapter.to_database(None, ipaddress.IPv4Address) is None
+
+
+@pytest.mark.parametrize("ip_str, expected_type", [
+    ("192.168.1.1", ipaddress.IPv4Address),
+    ("2001:db8::1", ipaddress.IPv6Address),
+    ("192.168.0.0/24", ipaddress.IPv4Network),
+    ("2001:db8::/32", ipaddress.IPv6Network),
+])
+def test_network_from_database(ip_str, expected_type):
+    adapter = PostgresNetworkAddressAdapter()
+    result = adapter.from_database(ip_str, expected_type)
+    assert isinstance(result, expected_type)
+    assert str(result) == ip_str
+
+
+def test_network_from_database_fallback():
+    """Test fallback behavior for invalid network strings."""
+    adapter = PostgresNetworkAddressAdapter()
+    invalid_str = "not-an-ip"
+    result = adapter.from_database(invalid_str, str)
+    assert result == invalid_str
+
+
+def test_network_from_database_none():
+    adapter = PostgresNetworkAddressAdapter()
+    assert adapter.from_database(None, ipaddress.IPv4Address) is None
+
+def test_network_from_database_no_ipaddress(mocker):
+    """Test that it returns the original value if ipaddress module is missing."""
+    mocker.patch('builtins.__import__', side_effect=ImportError)
+    adapter = PostgresNetworkAddressAdapter()
+    ip_str = "192.168.1.1"
+    assert adapter.from_database(ip_str, str) == ip_str
@@ -85,3 +85,47 @@ async def test_transaction_get_cursor(async_postgres_backend):
             await cursor.close()
     finally:
         await async_postgres_backend._connection.set_autocommit(original_autocommit_state)
+
+@pytest.mark.asyncio
+async def test_nested_transaction_rollback_inner(async_postgres_backend, setup_test_table):
+    """Test rolling back a nested async transaction while committing the outer one."""
+    async with async_postgres_backend.transaction():
+        # Outer transaction statement
+        await async_postgres_backend.execute("INSERT INTO test_table (name, age) VALUES (%s, %s)", ("outer", 40))
+
+        try:
+            async with async_postgres_backend.transaction():
+                # Inner transaction statement
+                await async_postgres_backend.execute("INSERT INTO test_table (name, age) VALUES (%s, %s)", ("inner", 50))
+                raise ValueError("Rollback inner transaction")
+        except ValueError:
+            # Expected exception
+            pass
+
+    # The outer transaction should be committed, but the inner one rolled back.
+    rows = await async_postgres_backend.fetch_all("SELECT * FROM test_table ORDER BY name")
+    assert len(rows) == 1
+    assert rows[0]['name'] == "outer"
+
+
+@pytest.mark.asyncio
+async def test_nested_transaction_rollback_outer(async_postgres_backend, setup_test_table):
+    """Test rolling back the outer async transaction after a nested one completes."""
+    try:
+        async with async_postgres_backend.transaction():
+            # Outer transaction statement
+            await async_postgres_backend.execute("INSERT INTO test_table (name, age) VALUES (%s, %s)", ("outer", 60))
+
+            async with async_postgres_backend.transaction():
+                # Inner transaction statement, this should be released to the outer savepoint
+                await async_postgres_backend.execute("INSERT INTO test_table (name, age) VALUES (%s, %s)", ("inner", 70))
+            
+            # This will cause the entire transaction, including the inner "committed" part, to be rolled back.
+            raise ValueError("Rollback outer transaction")
+    except ValueError:
+        # Expected exception
+        pass
+
+    # Nothing should have been committed.
+    count = await async_postgres_backend.fetch_one("SELECT COUNT(*) FROM test_table")
+    assert count['count'] == 0
@@ -0,0 +1,174 @@
+
+import pytest
+from rhosocial.activerecord.backend.impl.postgres.config import PostgresConnectionConfig
+
+def test_pg_config_to_dict():
+    """Test that postgres-specific parameters are added to the dictionary."""
+    config = PostgresConnectionConfig(
+        database="test_db",
+        sslmode="require",
+        application_name="my_app"
+    )
+    
+    config_dict = config.to_dict()
+    
+    # Test that the pg-specific parameters are present
+    assert config_dict['sslmode'] == 'require'
+    assert config_dict['application_name'] == 'my_app'
+    
+    # Test that parameters with default value None are not present
+    assert 'sslcert' not in config_dict
+
+def test_pg_config_to_connection_string_with_params():
+    """Test connection string builds correctly with various pg parameters."""
+    config = PostgresConnectionConfig(
+        host="localhost",
+        port=5432,
+        database="test_db",
+        username="user",
+        sslmode="verify-full",
+        application_name="my_app",
+        connect_timeout=20,
+        options={'custom_opt': 'custom_val'}
+    )
+    
+    conn_str = config.to_connection_string()
+    base_url, params_str = conn_str.split('?')
+    params = dict(p.split('=') for p in params_str.split('&'))
+    
+    assert base_url == "postgres://user@localhost:5432/test_db" # Password is None, so it's omitted
+    assert params['sslmode'] == 'verify-full'
+    assert params['application_name'] == 'my_app'
+    assert params['connect_timeout'] == '20'
+    assert params['custom_opt'] == 'custom_val'
+
+def test_pg_config_to_connection_string_no_auth():
+    """Test connection string with no username or password."""
+    config = PostgresConnectionConfig(host="localhost", port=5432, database="test_db")
+    assert config.to_connection_string() == "postgres://localhost:5432/test_db"
+
+def test_validation_missing_host():
+    """Test validation fails if host is missing."""
+    config = PostgresConnectionConfig(database="test_db", host=None)
+    with pytest.raises(ValueError, match="Host is required"):
+        config.validate()
+
+def test_validation_missing_database():
+    """Test validation fails if database is missing."""
+    config = PostgresConnectionConfig(host="localhost", database=None)
+    with pytest.raises(ValueError, match="Database name is required"):
+        config.validate()
+
+@pytest.mark.parametrize("invalid_port", [0, -1, 65536])
+def test_validation_invalid_port(invalid_port):
+    """Test validation fails for invalid port numbers."""
+    config = PostgresConnectionConfig(host="localhost", database="test_db", port=invalid_port)
+    with pytest.raises(ValueError, match=f"Invalid port number: {invalid_port}"):
+        config.validate()
+
+def test_validation_invalid_sslmode():
+    """Test validation fails for an invalid sslmode."""
+    config = PostgresConnectionConfig(host="localhost", database="test_db", sslmode="invalid_mode")
+    with pytest.raises(ValueError, match="Invalid sslmode"):
+        config.validate()
+
+def test_validation_invalid_session_attrs():
+    """Test validation fails for invalid target_session_attrs."""
+    config = PostgresConnectionConfig(
+        host="localhost",
+        database="test_db",
+        target_session_attrs="invalid_attr",
+    )
+    with pytest.raises(ValueError, match="Invalid target_session_attrs"):
+        config.validate()
+        
+@pytest.mark.parametrize("valid_session_attr", ["any", "primary", "standby", "prefer-standby", "read-write", "read-only"])
+def test_validation_valid_session_attrs(valid_session_attr):
+    """Test validation succeeds for valid target_session_attrs."""
+    config = PostgresConnectionConfig(
+        host="localhost",
+        database="test_db",
+        target_session_attrs=valid_session_attr,
+    )
+    assert config.validate() is True
+
+def test_validation_success():
+    """Test a valid configuration passes validation."""
+    config = PostgresConnectionConfig(
+        host="localhost",
+        database="test_db",
+        port=5432,
+        sslmode="require"
+    )
+    assert config.validate() is True
+
+def test_get_pool_config_defaults():
+    """Test getting pool config with default values."""
+    config = PostgresConnectionConfig(host="localhost", database="test_db")
+    pool_config = config.get_pool_config()
+    assert pool_config == {
+        "min_size": 1,
+        "max_size": 10,
+        "timeout": 30.0,
+    }
+
+def test_get_pool_config_custom():
+    """Test getting pool config with custom values from the mixin."""
+    config = PostgresConnectionConfig(
+        host="localhost",
+        database="test_db",
+        pool_min_size=5,
+        pool_max_size=20,
+        pool_timeout=60.5,
+    )
+    pool_config = config.get_pool_config()
+    assert pool_config == {
+        "min_size": 5,
+        "max_size": 20,
+        "timeout": 60.5,
+    }
+
+def test_connection_string_password_behavior():
+    """Test that connection string correctly handles password."""
+    # With password
+    config = PostgresConnectionConfig(host="h", database="d", username="u", password="p", port=5432)
+    assert config.to_connection_string() == "postgres://u:p@h:5432/d"
+    
+    # With username but no password
+    config = PostgresConnectionConfig(host="h", database="d", username="u", port=5432)
+    assert config.to_connection_string() == "postgres://u@h:5432/d"
+
+def test_connection_string_all_pg_params():
+    """Test that all pg-specific boolean and string params are in the conn string."""
+    config = PostgresConnectionConfig(
+        host="h", database="d", port=1,
+        sslmode='require',
+        sslcert='cert.pem',
+        sslkey='key.pem',
+        sslrootcert='root.crt',
+        sslcrl='crl.pem',
+        sslcompression=True,
+        application_name='app',
+        target_session_attrs='primary',
+        connect_timeout=15,
+        client_encoding='latin1',
+        service='my_service',
+        gssencmode='prefer',
+        channel_binding='require'
+    )
+    conn_str = config.to_connection_string()
+    
+    assert "sslmode=require" in conn_str
+    assert "sslcert=cert.pem" in conn_str
+    assert "sslkey=key.pem" in conn_str
+    assert "sslrootcert=root.crt" in conn_str
+    assert "sslcrl=crl.pem" in conn_str
+    assert "sslcompression=True" in conn_str
+    assert "application_name=app" in conn_str
+    assert "target_session_attrs=primary" in conn_str
+    assert "connect_timeout=15" in conn_str
+    assert "client_encoding=latin1" in conn_str
+    assert "service=my_service" in conn_str
+    assert "gssencmode=prefer" in conn_str
+    assert "channel_binding=require" in conn_str
+
@@ -0,0 +1,47 @@
+from rhosocial.activerecord.backend.impl.postgres.config import PostgresConnectionConfig
+from rhosocial.activerecord.backend.impl.postgres.dialect import PostgresDialect
+
+def test_format_limit_offset():
+    """Tests the format_limit_offset method of the PostgresDialect."""
+    dialect = PostgresDialect(config=PostgresConnectionConfig())
+
+    # Test with limit only
+    assert dialect.format_limit_offset(limit=10) == "LIMIT 10"
+
+    # Test with offset only
+    assert dialect.format_limit_offset(offset=5) == "OFFSET 5"
+
+    # Test with both limit and offset
+    assert dialect.format_limit_offset(limit=20, offset=10) == "LIMIT 20 OFFSET 10"
+
+    # Test with None values
+    assert dialect.format_limit_offset(limit=None, offset=None) == ""
+
+    # Test with zero values
+    assert dialect.format_limit_offset(limit=0, offset=0) == "LIMIT 0 OFFSET 0"
+
+def test_format_identifier():
+    """Tests the format_identifier method."""
+    dialect = PostgresDialect(config=PostgresConnectionConfig())
+
+    # Test simple identifier
+    assert dialect.format_identifier("my_table") == '"my_table"'
+
+    # The dialect should handle spaces by quoting
+    assert dialect.format_identifier("my table") == '"my table"'
+
+    # Test identifier with a double quote inside, which should be escaped
+    assert dialect.format_identifier('my"table') == '"my""table"'
+
+    # Test an identifier that is already quoted (it should be escaped and re-quoted)
+    assert dialect.format_identifier('"my_table"') == '"""my_table"""'
+
+def test_format_string_literal():
+    """Tests the format_string_literal method."""
+    dialect = PostgresDialect(config=PostgresConnectionConfig())
+
+    # Test a simple string
+    assert dialect.format_string_literal("hello") == "'hello'"
+
+    # Test a string with a single quote
+    assert dialect.format_string_literal("it's a test") == "'it''s a test'"