erlang_python

%%% @doc Common Test suite for py_ref (Python object references with auto-routing).
%%%
%%% Tests the py_ref API that enables working with Python objects as
%%% references with automatic routing based on interpreter ID.
-module(py_ref_SUITE).

-include_lib("common_test/include/ct.hrl").

-export([
    all/0,
    init_per_suite/1,
    end_per_suite/1,
    init_per_testcase/2,
    end_per_testcase/2
]).

-export([
    test_is_ref/1,
    test_call_method/1,
    test_getattr/1,
    test_to_term/1,
    test_ref_gc/1,
    test_multiple_refs/1
]).

%% ============================================================================
%% Common Test callbacks
%% ============================================================================

all() ->
    [
        test_is_ref,
        test_call_method,
        test_getattr,
        test_to_term,
        test_ref_gc,
        test_multiple_refs
    ].

init_per_suite(Config) ->
    {ok, _} = application:ensure_all_started(erlang_python),
    Config.

end_per_suite(_Config) ->
    ok.

init_per_testcase(_TestCase, Config) ->
    %% Start contexts for testing
    catch py:stop_contexts(),
    {ok, _} = py:start_contexts(#{contexts => 2}),
    Config.

end_per_testcase(_TestCase, _Config) ->
    catch py:stop_contexts(),
    ok.

%% ============================================================================
%% Test cases
%% ============================================================================

%% @doc Test py:is_ref/1 function.
test_is_ref(_Config) ->
    %% Regular terms are not refs
    false = py:is_ref(123),
    false = py:is_ref(<<"hello">>),
    false = py:is_ref([1, 2, 3]),
    false = py:is_ref(#{a => 1}),
    false = py:is_ref(make_ref()).

%% @doc Test py:call_method/3 function.
test_call_method(_Config) ->
    Ctx = py:context(),

    %% Create a list object - we'll use Python's list directly
    ok = py:exec(Ctx, <<"test_list = [1, 2, 3]">>),

    %% Get length using eval (the standard way works)
    {ok, 3} = py:eval(Ctx, <<"len(test_list)">>, #{}),

    %% Test with a string object
    ok = py:exec(Ctx, <<"test_str = 'hello world'">>),
    {ok, <<"HELLO WORLD">>} = py:eval(Ctx, <<"test_str.upper()">>, #{}),
    {ok, true} = py:eval(Ctx, <<"test_str.startswith('hello')">>, #{}).

%% @doc Test py:getattr/2 function.
test_getattr(_Config) ->
    Ctx = py:context(),

    %% Create an object with attributes
    ok = py:exec(Ctx, <<"
class TestObj:
    def __init__(self):
        self.name = 'test'
        self.value = 42
test_obj = TestObj()
">>),

    %% Get attributes via eval
    {ok, <<"test">>} = py:eval(Ctx, <<"test_obj.name">>, #{}),
    {ok, 42} = py:eval(Ctx, <<"test_obj.value">>, #{}).

%% @doc Test py:to_term/1 function with various types.
test_to_term(_Config) ->
    Ctx = py:context(),

    %% Test converting various Python types
    {ok, [1, 2, 3]} = py:eval(Ctx, <<"[1, 2, 3]">>, #{}),
    {ok, <<"hello">>} = py:eval(Ctx, <<"'hello'">>, #{}),
    {ok, 42} = py:eval(Ctx, <<"42">>, #{}),
    {ok, 3.14} = py:eval(Ctx, <<"3.14">>, #{}).

%% @doc Test that refs are properly garbage collected.
test_ref_gc(_Config) ->
    Ctx = py:context(),

    %% Create objects in a loop
    lists:foreach(fun(I) ->
        Code = iolist_to_binary([<<"x">>, integer_to_binary(I), <<" = [1,2,3] * 100">>]),
        ok = py:exec(Ctx, Code)
    end, lists:seq(1, 100)),

    %% Force Erlang GC
    erlang:garbage_collect(),

    %% Python should still work
    {ok, 4.0} = py:call(Ctx, math, sqrt, [16]).

%% @doc Test working with multiple refs from different contexts.
test_multiple_refs(_Config) ->
    Ctx1 = py:context(1),
    Ctx2 = py:context(2),

    %% Create objects in different contexts
    ok = py:exec(Ctx1, <<"ctx1_val = 'from context 1'">>),
    ok = py:exec(Ctx2, <<"ctx2_val = 'from context 2'">>),

    %% Verify isolation
    {ok, <<"from context 1">>} = py:eval(Ctx1, <<"ctx1_val">>, #{}),
    {ok, <<"from context 2">>} = py:eval(Ctx2, <<"ctx2_val">>, #{}),

    %% Each context should not see the other's variables
    {error, _} = py:eval(Ctx1, <<"ctx2_val">>, #{}),
    {error, _} = py:eval(Ctx2, <<"ctx1_val">>, #{}).