testcontainer_formulas

-module(testcontainer_formulas@redis).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/testcontainer_formulas/redis.gleam").
-export([new/0, with_image/2, with_version/2, with_password/2, with_secret_password/2, without_password/1, with_extra_wait/2, on_network/2, on_network_name/2, with_name/2, formula/1]).
-export_type([redis_container/0, redis_config/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Redis formula. Defaults to `redis:7-alpine` with no auth.\n"
    "\n"
    "     use cache <- testcontainer.with_formula(\n"
    "       redis.new() |> redis.formula(),\n"
    "     )\n"
    "\n"
    "     // cache.url, cache.host, cache.port\n"
).

-type redis_container() :: {redis_container,
        testcontainer@container:container(),
        binary(),
        binary(),
        integer()}.

-opaque redis_config() :: {redis_config,
        binary(),
        gleam@option:option(cowl:secret(binary())),
        gleam@option:option(testcontainer@wait:wait_strategy()),
        gleam@option:option(binary()),
        gleam@option:option(binary())}.

-file("src/testcontainer_formulas/redis.gleam", 43).
?DOC(" Sensible default: `redis:7-alpine`, no auth, no persistence.\n").
-spec new() -> redis_config().
new() ->
    {redis_config, <<"redis:7-alpine"/utf8>>, none, none, none, none}.

-file("src/testcontainer_formulas/redis.gleam", 54).
?DOC(" Replaces the image entirely.\n").
-spec with_image(redis_config(), binary()) -> redis_config().
with_image(C, Image) ->
    {redis_config,
        Image,
        erlang:element(3, C),
        erlang:element(4, C),
        erlang:element(5, C),
        erlang:element(6, C)}.

-file("src/testcontainer_formulas/redis.gleam", 59).
?DOC(" Shorthand for `redis:<version>`.\n").
-spec with_version(redis_config(), binary()) -> redis_config().
with_version(C, Version) ->
    {redis_config,
        <<"redis:"/utf8, Version/binary>>,
        erlang:element(3, C),
        erlang:element(4, C),
        erlang:element(5, C),
        erlang:element(6, C)}.

-file("src/testcontainer_formulas/redis.gleam", 64).
?DOC(" Enables Redis auth by starting `redis-server --requirepass <password>`.\n").
-spec with_password(redis_config(), binary()) -> redis_config().
with_password(C, Pass) ->
    {redis_config,
        erlang:element(2, C),
        {some, cowl:secret(Pass)},
        erlang:element(4, C),
        erlang:element(5, C),
        erlang:element(6, C)}.

-file("src/testcontainer_formulas/redis.gleam", 69).
?DOC(" Same as `with_password/2` when the value is already a `cowl.Secret`.\n").
-spec with_secret_password(redis_config(), cowl:secret(binary())) -> redis_config().
with_secret_password(C, Pass) ->
    {redis_config,
        erlang:element(2, C),
        {some, Pass},
        erlang:element(4, C),
        erlang:element(5, C),
        erlang:element(6, C)}.

-file("src/testcontainer_formulas/redis.gleam", 77).
?DOC(" Disables Redis auth (default behaviour).\n").
-spec without_password(redis_config()) -> redis_config().
without_password(C) ->
    {redis_config,
        erlang:element(2, C),
        none,
        erlang:element(4, C),
        erlang:element(5, C),
        erlang:element(6, C)}.

-file("src/testcontainer_formulas/redis.gleam", 83).
?DOC(
    " Adds an extra wait strategy on top of the default\n"
    " `log(\"Ready to accept connections\")`.\n"
).
-spec with_extra_wait(redis_config(), testcontainer@wait:wait_strategy()) -> redis_config().
with_extra_wait(C, S) ->
    {redis_config,
        erlang:element(2, C),
        erlang:element(3, C),
        {some, S},
        erlang:element(5, C),
        erlang:element(6, C)}.

-file("src/testcontainer_formulas/redis.gleam", 87).
-spec on_network(redis_config(), testcontainer@network:network()) -> redis_config().
on_network(C, Net) ->
    {redis_config,
        erlang:element(2, C),
        erlang:element(3, C),
        erlang:element(4, C),
        {some, testcontainer@network:name(Net)},
        erlang:element(6, C)}.

-file("src/testcontainer_formulas/redis.gleam", 92).
?DOC(" Same as `on_network/2` when you already have the Docker network name.\n").
-spec on_network_name(redis_config(), binary()) -> redis_config().
on_network_name(C, Net) ->
    {redis_config,
        erlang:element(2, C),
        erlang:element(3, C),
        erlang:element(4, C),
        {some, Net},
        erlang:element(6, C)}.

-file("src/testcontainer_formulas/redis.gleam", 96).
-spec with_name(redis_config(), binary()) -> redis_config().
with_name(C, N) ->
    {redis_config,
        erlang:element(2, C),
        erlang:element(3, C),
        erlang:element(4, C),
        erlang:element(5, C),
        {some, N}}.

-file("src/testcontainer_formulas/redis.gleam", 102).
?DOC(
    " Builds the `Formula(RedisContainer)` ready to pass to\n"
    " `testcontainer.with_formula/2`.\n"
).
-spec formula(redis_config()) -> testcontainer@formula:formula(redis_container()).
formula(C) ->
    Redis_port = testcontainer@port:tcp(6379),
    Base_wait = testcontainer@wait:log(<<"Ready to accept connections"/utf8>>),
    Wait_strategy = case erlang:element(4, C) of
        none ->
            Base_wait;

        {some, Extra} ->
            testcontainer@wait:all_of([Base_wait, Extra])
    end,
    With_basic = begin
        _pipe = testcontainer@container:new(erlang:element(2, C)),
        _pipe@1 = testcontainer@container:expose_port(_pipe, Redis_port),
        testcontainer@container:wait_for(_pipe@1, Wait_strategy)
    end,
    With_auth = case erlang:element(3, C) of
        none ->
            With_basic;

        {some, Pass} ->
            _pipe@2 = With_basic,
            testcontainer@container:with_command(
                _pipe@2,
                [<<"redis-server"/utf8>>,
                    <<"--requirepass"/utf8>>,
                    cowl:reveal(Pass)]
            )
    end,
    With_net = case erlang:element(5, C) of
        none ->
            With_auth;

        {some, N} ->
            _pipe@3 = With_auth,
            testcontainer@container:on_network(_pipe@3, N)
    end,
    Final_spec = case erlang:element(6, C) of
        none ->
            With_net;

        {some, N@1} ->
            _pipe@4 = With_net,
            testcontainer@container:with_name(_pipe@4, N@1)
    end,
    testcontainer@formula:new(
        Final_spec,
        fun(Running) ->
            gleam@result:'try'(
                testcontainer@container:host_port(Running, Redis_port),
                fun(Mapped_port) ->
                    Host = testcontainer@container:host(Running),
                    Url = case erlang:element(3, C) of
                        none ->
                            <<<<<<"redis://"/utf8, Host/binary>>/binary,
                                    ":"/utf8>>/binary,
                                (erlang:integer_to_binary(Mapped_port))/binary>>;

                        {some, Pass@1} ->
                            <<<<<<<<<<"redis://:"/utf8,
                                                (gleam_stdlib:percent_encode(
                                                    cowl:reveal(Pass@1)
                                                ))/binary>>/binary,
                                            "@"/utf8>>/binary,
                                        Host/binary>>/binary,
                                    ":"/utf8>>/binary,
                                (erlang:integer_to_binary(Mapped_port))/binary>>
                    end,
                    {ok, {redis_container, Running, Url, Host, Mapped_port}}
                end
            )
        end
    ).