- profiler/test_transaction_profiler.py

# imports
import inspect  # used to create frame objects for testing

import pytest  # used for our unit tests


# Mocking get_frame_name function
def get_frame_name(frame):
    return frame.f_code.co_name
from sentry_sdk.profiler.utils import frame_id

# unit tests

def test_basic_function_frame():
    """Test frame from a simple function in a single file."""
    def sample_function():
        frame = inspect.currentframe()
        return frame_id(frame)
    
    filename, lineno, name = sample_function()
    assert filename == __file__
    assert name == 'sample_function'

def test_method_in_class():
    """Test frame from a method in a class."""
    class SampleClass:
        def sample_method(self):
            frame = inspect.currentframe()
            return frame_id(frame)
    
    instance = SampleClass()
    filename, lineno, name = instance.sample_method()
    assert filename == __file__
    assert name == 'sample_method'

def test_nested_function():
    """Test frame from a nested function."""
    def outer_function():
        def inner_function():
            frame = inspect.currentframe()
            return frame_id(frame)
        return inner_function()
    
    filename, lineno, name = outer_function()
    assert filename == __file__
    assert name == 'inner_function'

def test_frame_with_no_filename():
    """Test frame with no filename (exec context)."""
    exec_code = """
def exec_function():
    frame = inspect.currentframe()
    return frame_id(frame)
result = exec_function()
"""
    exec_namespace = {}
    exec(exec_code, exec_namespace)
    filename, lineno, name = exec_namespace['result']
    assert filename == '<string>'
    assert name == 'exec_function'

def test_frame_with_no_lineno():
    """Test frame with no line number (manually set)."""
    def sample_function():
        frame = inspect.currentframe()
        frame.f_lineno = None
        return frame_id(frame)
    
    filename, lineno, name = sample_function()
    assert filename == __file__
    assert lineno is None
    assert name == 'sample_function'

def test_frame_with_empty_code_object():
    """Test frame with an empty code object."""
    def sample_function():
        frame = inspect.currentframe()
        frame.f_code = type('', (), {'co_filename': '', 'co_name': ''})()
        return frame_id(frame)
    
    filename, lineno, name = sample_function()
    assert filename == ''
    assert name == ''

def test_frame_from_module():
    """Test frame from a module."""
    frame = inspect.currentframe()
    filename, lineno, name = frame_id(frame)
    assert filename == __file__
    assert name == 'test_frame_from_module'

def test_frame_with_special_characters_in_filename():
    """Test frame from a file with special characters in the filename."""
    def special_char_function():
        frame = inspect.currentframe()
        frame.f_code = type('', (), {'co_filename': 'special!@#$.py', 'co_name': 'special_char_function'})()
        return frame_id(frame)
    
    filename, lineno, name = special_char_function()
    assert filename == 'special!@#$.py'
    assert name == 'special_char_function'

def test_frame_from_large_script():
    """Test frame from a large script with thousands of lines."""
    def large_script_function():
        frame = inspect.currentframe()
        frame.f_lineno = 1000
        return frame_id(frame)
    
    filename, lineno, name = large_script_function()
    assert filename == __file__
    assert lineno == 1000
    assert name == 'large_script_function'

def test_frame_from_thread():
    """Test frame from a function executed in a thread."""
    import threading
    result = []
    def thread_function():
        frame = inspect.currentframe()
        result.append(frame_id(frame))
    
    thread = threading.Thread(target=thread_function)
    thread.start()
    thread.join()
    
    filename, lineno, name = result[0]
    assert filename == __file__
    assert name == 'thread_function'

def test_frame_from_async_function():
    """Test frame from an async function."""
    import asyncio
    async def async_function():
        frame = inspect.currentframe()
        return frame_id(frame)
    
    loop = asyncio.get_event_loop()
    filename, lineno, name = loop.run_until_complete(async_function())
    assert filename == __file__
    assert name == 'async_function'

def test_frame_from_subprocess():
    """Test frame from a function executed in a subprocess."""
    import subprocess
    import sys
    code = """
import inspect
def subprocess_function():
    frame = inspect.currentframe()
    print(frame.f_code.co_filename, frame.f_lineno, frame.f_code.co_name)
subprocess_function()
"""
    result = subprocess.run([sys.executable, '-c', code], capture_output=True, text=True)
    output = result.stdout.strip().split()
    filename, lineno, name = output[0], int(output[1]), output[2]
    assert filename == '<string>'
    assert name == 'subprocess_function'