⚡️ Speed up method BookStackDataSource.update_role by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for BookStackDataSource.update_role in backend/python/app/sources/external/bookstack/bookstack.py

⏱️ Runtime : 3.17 milliseconds → 2.97 milliseconds (best of 230 runs)

📝 Explanation and details

The optimized code achieves a 7% runtime improvement through two key changes:

1. String Formatting Optimization

• Changed: self.base_url + "/api/roles/{id}".format(id=id)
• To: f"{self.base_url}/api/roles/{id}"
• Impact: F-strings are significantly faster than .format() calls. The line profiler shows URL construction time reduced from 629.8ns to 351.9ns per hit (44% faster for this operation)

2. Headers Copy Method

• Changed: dict(self.http.headers)
• To: self.http.headers.copy()
• Impact: Direct .copy() method avoids the overhead of the dict() constructor when the source is already a dictionary, reducing time from 363.1ns to 326.6ns per hit (10% faster)

Why These Optimizations Matter:

• F-strings use bytecode optimization and avoid method lookup overhead compared to .format()
• .copy() is a native dict method that's more efficient than constructor-based copying
• Both optimizations are particularly beneficial for high-throughput scenarios where the function is called repeatedly

Test Performance:
The optimizations show consistent benefits across all test scenarios, with throughput improving by 0.4% (168,773 to 169,510 ops/sec). The improvements are most noticeable in large-scale concurrent tests where string operations are executed hundreds of times rapidly.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 768 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	95.2%

🌀 Generated Regression Tests and Runtime

import asyncio  # used to run async functions
# --- Function under test (EXACT COPY) ---
from typing import Dict, List, Optional, Union

import pytest  # used for our unit tests
from app.sources.external.bookstack.bookstack import BookStackDataSource

# --- Begin: Minimal stubs for dependencies ---

# Minimal stub for HTTPRequest
class HTTPRequest:
    def __init__(self, method, url, headers, query_params, body):
        self.method = method
        self.url = url
        self.headers = headers
        self.query_params = query_params
        self.body = body
        self.path_params = {}

# Minimal stub for BookStackResponse
class BookStackResponse:
    def __init__(self, success, data=None, error=None):
        self.success = success
        self.data = data
        self.error = error

# Minimal stub for BookStackRESTClientViaToken
class BookStackRESTClientViaToken:
    def __init__(self, base_url, token_id, token_secret):
        self.base_url = base_url.rstrip('/')
        self.headers = {
            "Authorization": f"Token {token_id}:{token_secret}",
            "Content-Type": "application/json",
            "Accept": "application/json"
        }

    def get_base_url(self):
        return self.base_url

    async def execute(self, request, **kwargs):
        # Simulate a successful update with echo of input
        # If id is 0, simulate not found
        if "/api/roles/0" in request.url:
            raise Exception("Role not found")
        # Simulate permissions validation
        if "permissions" in request.body and not isinstance(request.body["permissions"], list):
            raise Exception("Invalid permissions format")
        # Simulate large payload handling
        if "display_name" in request.body and isinstance(request.body["display_name"], str) and len(request.body["display_name"]) > 500:
            # Accept but mark as large
            return HTTPResponse(MockResponse({"updated": True, "note": "large display_name"}))
        # Simulate normal case
        return HTTPResponse(MockResponse({"updated": True, "role_id": request.url.split("/")[-1], "body": request.body}))

# Minimal stub for BookStackClient
class BookStackClient:
    def __init__(self, client):
        self.client = client

    def get_client(self):
        return self.client

# Minimal stub for MockResponse
class MockResponse:
    def __init__(self, data):
        self._data = data

    def json(self):
        return self._data
from app.sources.external.bookstack.bookstack import BookStackDataSource

# --- Unit Tests ---

@pytest.fixture
def datasource():
    # Setup a BookStackDataSource with minimal stub client
    client = BookStackRESTClientViaToken("http://localhost", "tokenid", "tokensecret")
    bsc = BookStackClient(client)
    return BookStackDataSource(bsc)

# 1. Basic Test Cases

@pytest.mark.asyncio
async def test_update_role_basic_success(datasource):
    # Test updating a role with all fields provided
    result = await datasource.update_role(
        id=1,
        display_name="New Role Name",
        description="Updated description",
        mfa_enforced=True,
        external_auth_id="authid123",
        permissions=["perm.read", "perm.write"]
    )

@pytest.mark.asyncio
async def test_update_role_basic_partial_fields(datasource):
    # Test updating a role with only some fields provided
    result = await datasource.update_role(
        id=2,
        display_name="Partial Name"
    )

@pytest.mark.asyncio
async def test_update_role_basic_minimal(datasource):
    # Test updating a role with only the required id
    result = await datasource.update_role(id=3)

# 2. Edge Test Cases

@pytest.mark.asyncio
async def test_update_role_edge_invalid_id(datasource):
    # Test updating a role with a non-existent id (simulate error)
    result = await datasource.update_role(id=0)

@pytest.mark.asyncio
async def test_update_role_edge_invalid_permissions_type(datasource):
    # Test updating a role with permissions as a non-list (should error)
    # This simulates a type error in permissions
    result = await datasource.update_role(id=4, permissions="notalist")

@pytest.mark.asyncio
async def test_update_role_edge_empty_permissions(datasource):
    # Test updating a role with empty permissions list
    result = await datasource.update_role(id=5, permissions=[])

@pytest.mark.asyncio
async def test_update_role_edge_large_display_name(datasource):
    # Test updating a role with a very large display_name string
    large_name = "A" * 600
    result = await datasource.update_role(id=6, display_name=large_name)

@pytest.mark.asyncio
async def test_update_role_edge_concurrent_updates(datasource):
    # Test concurrent updates to different roles
    coros = [
        datasource.update_role(id=10, display_name="RoleA"),
        datasource.update_role(id=11, display_name="RoleB"),
        datasource.update_role(id=12, display_name="RoleC"),
    ]
    results = await asyncio.gather(*coros)
    # Each should succeed and have correct display_name
    for i, result in enumerate(results):
        pass

# 3. Large Scale Test Cases

@pytest.mark.asyncio
async def test_update_role_large_scale_many_concurrent(datasource):
    # Test updating many roles concurrently (up to 50)
    coros = [
        datasource.update_role(id=i, display_name=f"Role_{i}", permissions=["perm.read"])
        for i in range(20, 70)
    ]
    results = await asyncio.gather(*coros)
    # All should succeed and have correct id and body
    for i, result in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_update_role_large_scale_varied_payloads(datasource):
    # Test updating roles with varied payloads concurrently
    coros = [
        datasource.update_role(id=100+i, display_name=f"Role_{i}", description=("Desc" if i%2==0 else None),
                               mfa_enforced=(i%3==0), permissions=["perm.a", "perm.b"])
        for i in range(10)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(results):
        if i%2==0:
            pass
        else:
            pass

# 4. Throughput Test Cases

@pytest.mark.asyncio
async def test_update_role_throughput_small_load(datasource):
    # Throughput test: small batch of updates
    coros = [
        datasource.update_role(id=200+i, display_name=f"SmallLoad_{i}")
        for i in range(5)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_update_role_throughput_medium_load(datasource):
    # Throughput test: medium batch of updates
    coros = [
        datasource.update_role(id=300+i, display_name=f"MediumLoad_{i}", permissions=["perm.medium"])
        for i in range(20)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_update_role_throughput_high_volume(datasource):
    # Throughput test: high volume batch of updates (limit to 100 for speed)
    coros = [
        datasource.update_role(id=400+i, display_name=f"HighLoad_{i}", permissions=["perm.high"])
        for i in range(100)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_update_role_throughput_payload_size(datasource):
    # Throughput test: update roles with large payloads (but bounded)
    large_desc = "D" * 400
    coros = [
        datasource.update_role(id=500+i, display_name="X"*100, description=large_desc, permissions=["perm.large"])
        for i in range(10)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import asyncio  # used to run async functions
# Function under test (EXACT COPY, DO NOT MODIFY)
from typing import Dict, List, Optional, Union

import pytest  # used for our unit tests
from app.sources.external.bookstack.bookstack import BookStackDataSource

# Mocks for HTTPRequest, HTTPResponse, HTTPClient, BookStackResponse, BookStackClient

class HTTPRequest:
    def __init__(self, method, url, headers=None, query_params=None, body=None):
        self.method = method
        self.url = url
        self.headers = headers or {}
        self.query_params = query_params or {}
        self.body = body

class BookStackResponse:
    def __init__(self, success, data=None, error=None):
        self.success = success
        self.data = data
        self.error = error

class DummyHTTPClient:
    def __init__(self):
        self.headers = {
            "Authorization": "Token dummy:dummy",
            "Content-Type": "application/json",
            "Accept": "application/json"
        }
        self._base_url = "https://bookstack.example.com"
        self._responses = {}
        self._raise_exc = False
        self._exc_to_raise = Exception("Simulated error")

    def get_base_url(self):
        return self._base_url

    async def execute(self, request, **kwargs):
        # Simulate raising exception if flag is set
        if self._raise_exc:
            raise self._exc_to_raise
        # Simulate response based on request body for test purposes
        key = (
            request.url,
            str(request.body)
        )
        # Return a predictable response for testing
        return HTTPResponse({
            "id": int(request.url.split("/")[-1]),
            "display_name": request.body.get("display_name"),
            "description": request.body.get("description"),
            "mfa_enforced": request.body.get("mfa_enforced"),
            "external_auth_id": request.body.get("external_auth_id"),
            "permissions": request.body.get("permissions"),
            "method": request.method,
            "headers": request.headers,
            "query_params": request.query_params,
            "body": request.body
        })

class BookStackClient:
    def __init__(self, client):
        self.client = client

    def get_client(self):
        return self.client
from app.sources.external.bookstack.bookstack import BookStackDataSource

# -------------------- UNIT TESTS --------------------

@pytest.fixture
def datasource():
    """Fixture for BookStackDataSource with dummy client"""
    client = BookStackClient(DummyHTTPClient())
    return BookStackDataSource(client)

@pytest.mark.asyncio
async def test_update_role_basic_success(datasource):
    """Basic: Update role with all fields provided"""
    resp = await datasource.update_role(
        id=1,
        display_name="Admin",
        description="Administrator role",
        mfa_enforced=True,
        external_auth_id="ext123",
        permissions=["manage-users", "manage-content"]
    )

@pytest.mark.asyncio
async def test_update_role_basic_minimal_fields(datasource):
    """Basic: Update role with only required field (id)"""
    resp = await datasource.update_role(id=2)

@pytest.mark.asyncio
async def test_update_role_basic_partial_fields(datasource):
    """Basic: Update role with some optional fields"""
    resp = await datasource.update_role(
        id=3,
        display_name="Editor",
        permissions=["edit-pages"]
    )

# Edge case: id as 0
@pytest.mark.asyncio
async def test_update_role_edge_id_zero(datasource):
    """Edge: Update role with id=0 (boundary value)"""
    resp = await datasource.update_role(id=0)

# Edge case: id as negative
@pytest.mark.asyncio
async def test_update_role_edge_id_negative(datasource):
    """Edge: Update role with negative id"""
    resp = await datasource.update_role(id=-1)

# Edge case: Empty strings and empty list
@pytest.mark.asyncio
async def test_update_role_edge_empty_strings_and_list(datasource):
    """Edge: Update role with empty strings and empty permissions list"""
    resp = await datasource.update_role(
        id=4,
        display_name="",
        description="",
        external_auth_id="",
        permissions=[]
    )

# Edge case: permissions is None vs empty list
@pytest.mark.asyncio
async def test_update_role_edge_permissions_none_vs_empty(datasource):
    """Edge: Compare permissions=None vs permissions=[]"""
    resp_none = await datasource.update_role(id=5, permissions=None)
    resp_empty = await datasource.update_role(id=5, permissions=[])

# Edge case: mfa_enforced True/False
@pytest.mark.asyncio
async def test_update_role_edge_mfa_enforced_true_false(datasource):
    """Edge: Test mfa_enforced True and False"""
    resp_true = await datasource.update_role(id=6, mfa_enforced=True)
    resp_false = await datasource.update_role(id=7, mfa_enforced=False)

# Edge case: Exception handling
@pytest.mark.asyncio
async def test_update_role_edge_exception_handling():
    """Edge: Simulate HTTP client raising exception"""
    client = BookStackClient(DummyHTTPClient())
    client.client._raise_exc = True
    datasource = BookStackDataSource(client)
    resp = await datasource.update_role(id=8)

# Edge case: Large permissions list
@pytest.mark.asyncio
async def test_update_role_edge_large_permissions(datasource):
    """Edge: Large permissions list (<=1000 elements)"""
    perms = [f"perm_{i}" for i in range(1000)]
    resp = await datasource.update_role(id=9, permissions=perms)

# Edge case: Concurrent execution
@pytest.mark.asyncio
async def test_update_role_edge_concurrent_execution(datasource):
    """Edge: Run multiple update_role calls concurrently"""
    tasks = [
        datasource.update_role(id=i, display_name=f"Role {i}")
        for i in range(10)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        pass

# Large scale: Many concurrent calls
@pytest.mark.asyncio
async def test_update_role_large_scale_concurrent(datasource):
    """Large scale: 100 concurrent update_role calls"""
    tasks = [
        datasource.update_role(id=i, display_name=f"LargeRole{i}")
        for i in range(100)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        pass

# Large scale: Stress test with mixed parameters
@pytest.mark.asyncio
async def test_update_role_large_scale_mixed_parameters(datasource):
    """Large scale: 50 concurrent calls with mixed parameters"""
    tasks = []
    for i in range(50):
        if i % 2 == 0:
            tasks.append(datasource.update_role(id=i, description=f"Desc{i}"))
        else:
            tasks.append(datasource.update_role(
                id=i,
                display_name=f"Role{i}",
                permissions=[f"perm_{i}", f"perm_{i+1}"]
            ))
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        pass

# Throughput: Small load
@pytest.mark.asyncio
async def test_update_role_throughput_small_load(datasource):
    """Throughput: Small load (10 sequential calls)"""
    for i in range(10):
        resp = await datasource.update_role(id=i, display_name=f"TP_Small_{i}")

# Throughput: Medium load (50 concurrent calls)
@pytest.mark.asyncio
async def test_update_role_throughput_medium_load(datasource):
    """Throughput: Medium load (50 concurrent calls)"""
    tasks = [
        datasource.update_role(id=i, display_name=f"TP_Medium_{i}")
        for i in range(50)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        pass

# Throughput: High volume (200 concurrent calls)
@pytest.mark.asyncio
async def test_update_role_throughput_high_volume(datasource):
    """Throughput: High volume (200 concurrent calls)"""
    tasks = [
        datasource.update_role(id=i, display_name=f"TP_High_{i}")
        for i in range(200)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        pass

# Throughput: Sustained execution pattern
@pytest.mark.asyncio
async def test_update_role_throughput_sustained(datasource):
    """Throughput: Sustained execution - 5 rounds of 20 concurrent calls"""
    for round_num in range(5):
        tasks = [
            datasource.update_role(id=round_num*20 + i, display_name=f"TP_Sustained_{round_num}_{i}")
            for i in range(20)
        ]
        results = await asyncio.gather(*tasks)
        for i, resp in enumerate(results):
            pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from app.sources.external.bookstack.bookstack import BookStackDataSource

To edit these changes git checkout codeflash/optimize-BookStackDataSource.update_role-mhbngf8e and push.