From 752163545fe7f80a2719c810ee0ba1c52a5f2d9b Mon Sep 17 00:00:00 2001 From: jaeyson Date: Sun, 30 Jun 2024 10:26:37 +0800 Subject: [PATCH 1/5] update readme for setting up connections in test.exs --- README.md | 14 +++++++++----- mix.lock | 4 ++-- test/cluster_test.exs | 2 +- test/collection_test.exs | 2 +- test/connection_test.exs | 2 +- test/document_test.exs | 2 +- test/search_test.exs | 2 +- 7 files changed, 16 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index 3a2fbdb..8659d32 100644 --- a/README.md +++ b/README.md @@ -55,13 +55,17 @@ After you have setup a [local](./guides/running_local_typesense.md) Typesense or You can set the following config details to the config file: ```elixir -config :ex_typesense, - api_key: "xyz", - host: "localhost", - port: 8108, - scheme: "http" +if config_env() == :prod do # if you'll use this in prod environment + config :ex_typesense, + api_key: "xyz", + host: "localhost", + port: 8108, + scheme: "http" + ... ``` +> **Note**: If you use this for adding test in your app, you might want to add this in `config/test.exs`: + For Cloud hosted, you can generate and obtain the credentials from cluster instance admin interface: ```elixir diff --git a/mix.lock b/mix.lock index 1e576cb..7e5cf11 100644 --- a/mix.lock +++ b/mix.lock @@ -15,12 +15,12 @@ "makeup_elixir": {:hex, :makeup_elixir, "0.16.2", "627e84b8e8bf22e60a2579dad15067c755531fea049ae26ef1020cad58fe9578", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "41193978704763f6bbe6cc2758b84909e62984c7752b3784bd3c218bb341706b"}, "makeup_erlang": {:hex, :makeup_erlang, "1.0.0", "6f0eff9c9c489f26b69b61440bf1b238d95badae49adac77973cbacae87e3c2e", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "ea7a9307de9d1548d2a72d299058d1fd2339e3d398560a0e46c27dab4891e4d2"}, "mime": {:hex, :mime, "2.0.5", "dc34c8efd439abe6ae0343edbb8556f4d63f178594894720607772a041b04b02", [:mix], [], "hexpm", "da0d64a365c45bc9935cc5c8a7fc5e49a0e0f9932a761c55d6c52b142780a05c"}, - "mint": {:hex, :mint, "1.6.0", "88a4f91cd690508a04ff1c3e28952f322528934be541844d54e0ceb765f01d5e", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "3c5ae85d90a5aca0a49c0d8b67360bbe407f3b54f1030a111047ff988e8fefaa"}, + "mint": {:hex, :mint, "1.6.1", "065e8a5bc9bbd46a41099dfea3e0656436c5cbcb6e741c80bd2bad5cd872446f", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "4fc518dcc191d02f433393a72a7ba3f6f94b101d094cb6bf532ea54c89423780"}, "mix_audit": {:hex, :mix_audit, "2.1.3", "c70983d5cab5dca923f9a6efe559abfb4ec3f8e87762f02bab00fa4106d17eda", [:make, :mix], [{:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:yaml_elixir, "~> 2.9", [hex: :yaml_elixir, repo: "hexpm", optional: false]}], "hexpm", "8c3987100b23099aea2f2df0af4d296701efd031affb08d0746b2be9e35988ec"}, "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"}, "nimble_parsec": {:hex, :nimble_parsec, "1.4.0", "51f9b613ea62cfa97b25ccc2c1b4216e81df970acd8e16e8d1bdc58fef21370d", [:mix], [], "hexpm", "9c565862810fb383e9838c1dd2d7d2c437b3d13b267414ba6af33e50d2d1cf28"}, "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"}, - "req": {:hex, :req, "0.5.0", "6d8a77c25cfc03e06a439fb12ffb51beade53e3fe0e2c5e362899a18b50298b3", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "dda04878c1396eebbfdec6db6f3d4ca609e5c8846b7ee88cc56eb9891406f7a3"}, + "req": {:hex, :req, "0.5.1", "90584216d064389a4ff2d4279fe2c11ff6c812ab00fa01a9fb9d15457f65ba70", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "7ea96a1a95388eb0fefa92d89466cdfedba24032794e5c1147d78ec90db7edca"}, "telemetry": {:hex, :telemetry, "1.2.1", "68fdfe8d8f05a8428483a97d7aab2f268aaff24b49e0f599faa091f1d4e7f61c", [:rebar3], [], "hexpm", "dad9ce9d8effc621708f99eac538ef1cbe05d6a874dd741de2e689c47feafed5"}, "yamerl": {:hex, :yamerl, "0.10.0", "4ff81fee2f1f6a46f1700c0d880b24d193ddb74bd14ef42cb0bcf46e81ef2f8e", [:rebar3], [], "hexpm", "346adb2963f1051dc837a2364e4acf6eb7d80097c0f53cbdc3046ec8ec4b4e6e"}, "yaml_elixir": {:hex, :yaml_elixir, "2.9.0", "9a256da867b37b8d2c1ffd5d9de373a4fda77a32a45b452f1708508ba7bbcb53", [:mix], [{:yamerl, "~> 0.10", [hex: :yamerl, repo: "hexpm", optional: false]}], "hexpm", "0cb0e7d4c56f5e99a6253ed1a670ed0e39c13fc45a6da054033928607ac08dfc"}, diff --git a/test/cluster_test.exs b/test/cluster_test.exs index f5e7c54..a6588a7 100644 --- a/test/cluster_test.exs +++ b/test/cluster_test.exs @@ -1,5 +1,5 @@ defmodule ClusterTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true setup_all do %{ diff --git a/test/collection_test.exs b/test/collection_test.exs index 295435a..1cafe87 100644 --- a/test/collection_test.exs +++ b/test/collection_test.exs @@ -1,5 +1,5 @@ defmodule CollectionTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true setup_all do conn = %ExTypesense.Connection{ diff --git a/test/connection_test.exs b/test/connection_test.exs index e5d7056..5d7d2bb 100644 --- a/test/connection_test.exs +++ b/test/connection_test.exs @@ -1,5 +1,5 @@ defmodule ConnectionTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true alias ExTypesense.TestSchema.Credential setup_all do diff --git a/test/document_test.exs b/test/document_test.exs index d6d98ef..95b0b1b 100644 --- a/test/document_test.exs +++ b/test/document_test.exs @@ -1,5 +1,5 @@ defmodule DocumentTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true alias ExTypesense.TestSchema.Person diff --git a/test/search_test.exs b/test/search_test.exs index 26ea741..323bc5a 100644 --- a/test/search_test.exs +++ b/test/search_test.exs @@ -1,5 +1,5 @@ defmodule SearchTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true import Ecto.Query, warn: false alias ExTypesense.TestSchema.Person From 670987ed0170e10dee0ac76006e4c50bccadbf19 Mon Sep 17 00:00:00 2001 From: "Jaeyson Anthony Y." Date: Sun, 30 Jun 2024 20:19:22 +0800 Subject: [PATCH 2/5] wip change from struct to map --- .github/workflows/ci.yml | 4 +-- .iex.exs | 5 ++++ README.md | 2 +- lib/ex_typesense/cluster.ex | 1 + lib/ex_typesense/collection.ex | 3 ++ lib/ex_typesense/connection.ex | 37 +++++++++++++++++++------ lib/ex_typesense/document.ex | 2 ++ lib/ex_typesense/http_client.ex | 34 +++++++++++++++++++++-- test/cluster_test.exs | 49 +++++++++++++++++++++++++-------- test/collection_test.exs | 2 +- test/connection_test.exs | 2 +- test/document_test.exs | 20 ++++++-------- test/search_test.exs | 2 +- 13 files changed, 123 insertions(+), 40 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b9d4752..6255799 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -64,9 +64,9 @@ jobs: path: | deps _build - key: ${{ runner.os }}-mix-${{ hashFiles('**/mix.lock') }} + key: ${{ runner.os }}-mix-typesense-${{ matrix.typesense-version }}-${{ hashFiles('**/mix.lock') }} restore-keys: | - ${{ runner.os }}-mix- + ${{ runner.os }}-mix-typesense-${{ matrix.typesense-version }} - name: Install Dependencies run: | diff --git a/.iex.exs b/.iex.exs index 1362b41..115c75d 100644 --- a/.iex.exs +++ b/.iex.exs @@ -1,3 +1,8 @@ +alias ExTypesense.Cluster alias ExTypesense.Collection +alias ExTypesense.Connection alias ExTypesense.Document alias ExTypesense.HttpClient +alias ExTypesense.Search +alias ExTypesense.TestSchema.Credential +alias ExTypesense.TestSchema.Person diff --git a/README.md b/README.md index 8659d32..0be9258 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ Typesense client for Elixir with support for your Ecto schemas. -**Note**: Breaking changes if you're upgrading from `0.3.x` to upcoming `0.5.x` version. +> **Note**: Breaking changes if you're upgrading from `0.3.x` to upcoming `0.5.x` version. ## Todo diff --git a/lib/ex_typesense/cluster.ex b/lib/ex_typesense/cluster.ex index 8aea329..8338bde 100644 --- a/lib/ex_typesense/cluster.ex +++ b/lib/ex_typesense/cluster.ex @@ -7,6 +7,7 @@ defmodule ExTypesense.Cluster do alias ExTypesense.Connection alias ExTypesense.HttpClient + @typedoc since: "0.3.0" @type response() :: any() | {:ok, any()} | {:error, map()} @doc """ diff --git a/lib/ex_typesense/collection.ex b/lib/ex_typesense/collection.ex index afceff8..9abcd34 100644 --- a/lib/ex_typesense/collection.ex +++ b/lib/ex_typesense/collection.ex @@ -29,6 +29,7 @@ defmodule ExTypesense.Collection do :vec_dist ] + @typedoc since: "0.1.0" @type t() :: %__MODULE__{ facet: boolean(), index: boolean(), @@ -44,6 +45,7 @@ defmodule ExTypesense.Collection do vec_dist: String.t() } + @typedoc since: "0.1.0" @type field_type() :: :string | :"string[]" @@ -95,6 +97,7 @@ defmodule ExTypesense.Collection do symbols_to_index: list() } + @typedoc since: "0.1.0" @type response() :: t() | [t() | map()] | map() | {:error, map()} @doc """ diff --git a/lib/ex_typesense/connection.ex b/lib/ex_typesense/connection.ex index c616206..ebb7a55 100644 --- a/lib/ex_typesense/connection.ex +++ b/lib/ex_typesense/connection.ex @@ -4,25 +4,44 @@ defmodule ExTypesense.Connection do Fetches credentials either from application env or map. """ - @derive {Inspect, except: [:api_key]} - defstruct host: ExTypesense.HttpClient.get_host(), - api_key: ExTypesense.HttpClient.api_key(), - port: ExTypesense.HttpClient.get_port(), - scheme: ExTypesense.HttpClient.get_scheme() + alias ExTypesense.HttpClient - @type t() :: %__MODULE__{} + # @derive {Inspect, except: [:api_key]} + # defstruct host: HttpClient.get_host(), + # api_key: HttpClient.api_key(), + # port: HttpClient.get_port(), + # scheme: HttpClient.get_scheme() + + @typedoc since: "0.4.0" + @type t() :: %{ + host: String.t() | nil, + api_key: String.t() | nil, + port: non_neg_integer() | nil, + scheme: String.t() | nil + } @doc """ Fetches credentials either from application env or map. """ @doc since: "0.4.0" - @spec new(connection :: struct() | map()) :: ExTypesense.Connection.t() - def new(connection \\ %__MODULE__{}) when is_struct(connection) do - %__MODULE__{ + @spec new(connection :: t() | map()) :: ExTypesense.Connection.t() + def new(connection \\ defaults()) when is_map(connection) do + %{ host: Map.get(connection, :host), api_key: Map.get(connection, :api_key), port: Map.get(connection, :port), scheme: Map.get(connection, :scheme) } end + + @doc since: "0.4.3" + @spec defaults :: map() + defp defaults do + %{ + host: HttpClient.get_host(), + api_key: HttpClient.api_key(), + port: HttpClient.get_port(), + scheme: HttpClient.get_scheme() + } + end end diff --git a/lib/ex_typesense/document.ex b/lib/ex_typesense/document.ex index 6d5ffb4..a6a66ff 100644 --- a/lib/ex_typesense/document.ex +++ b/lib/ex_typesense/document.ex @@ -12,6 +12,8 @@ defmodule ExTypesense.Document do @collections_path @root_path <> "collections" @documents_path "documents" @import_path "import" + + @typedoc since: "0.1.0" @type response :: :ok | {:ok, map()} | {:error, map()} @doc """ diff --git a/lib/ex_typesense/http_client.ex b/lib/ex_typesense/http_client.ex index 39e914f..7ed42a8 100644 --- a/lib/ex_typesense/http_client.ex +++ b/lib/ex_typesense/http_client.ex @@ -6,15 +6,41 @@ defmodule ExTypesense.HttpClient do alias ExTypesense.Connection + @typedoc since: "0.1.0" @type request_body() :: iodata() | nil + + @typedoc since: "0.1.0" @type request_method() :: :get | :post | :delete | :patch | :put + + @typedoc since: "0.1.0" @type request_path() :: String.t() @api_header_name ~c"X-TYPESENSE-API-KEY" + @doc since: "0.1.0" + @spec get_host :: String.t() | nil def get_host, do: Application.get_env(:ex_typesense, :host) - def get_port, do: Application.get_env(:ex_typesense, :port) + + @doc since: "0.1.0" + @spec get_scheme :: String.t() | nil def get_scheme, do: Application.get_env(:ex_typesense, :scheme) + + @doc since: "0.1.0" + @spec get_port :: non_neg_integer() | nil + def get_port do + Application.get_env(:ex_typesense, :port) + end + + @doc """ + Returns the Typesense's API key + + > #### Warning {: .warning} + > + > Even if `api_key` is hidden in `Connection` struct, this + > function will still return the key and accessible inside + > shell (assuming bad actors [pun unintended `:/`] can get in as well). + """ + @spec api_key :: String.t() | nil def api_key, do: Application.get_env(:ex_typesense, :api_key) @doc """ @@ -49,8 +75,10 @@ defmodule ExTypesense.HttpClient do } """ @doc since: "0.4.0" - @spec request(Connection.t(), map()) :: nil + @spec request(Connection.t(), map()) :: {:ok, any()} | {:error, String.t()} def request(conn, opts \\ %{}) do + retry = if opts[:retry], do: opts[:retry], else: &Req.Steps.retry/1 + url = %URI{ scheme: conn.scheme, @@ -68,7 +96,7 @@ defmodule ExTypesense.HttpClient do } |> Req.Request.put_header("x-typesense-api-key", conn.api_key) |> Req.Request.put_header("content-type", opts[:content_type] || "application/json") - |> Req.Request.append_error_steps(retry: &Req.Steps.retry/1) + |> Req.Request.append_error_steps(retry: retry) |> Req.Request.run!() case response.status in 200..299 do diff --git a/test/cluster_test.exs b/test/cluster_test.exs index a6588a7..9b0dcfb 100644 --- a/test/cluster_test.exs +++ b/test/cluster_test.exs @@ -1,26 +1,53 @@ defmodule ClusterTest do - use ExUnit.Case, async: true + use ExUnit.Case, async: false setup_all do - %{ - conn: %ExTypesense.Connection{ - host: "localhost", + Application.put_all_env( + ex_typesense: [ api_key: "xyz", + host: "localhost", port: 8108, scheme: "http" - } - } + ] + ) + + on_exit(fn -> + # this is for deprecated function to set the creds + [:api_key, :host, :port, :scheme] + |> Enum.each(&Application.delete_env(:ex_typesense, &1)) + end) + + :ok end test "health", context do - assert {:ok, true} = ExTypesense.health(context.conn) + assert {:ok, true} = ExTypesense.health() + # assert_raise FunctionClauseError, fn -> + # ExTypesense.health() + # end + # assert_raise FunctionClauseError, fn -> + # Enum.chunk([1, 2, 3], 0) + # end end - test "api status", context do - assert {:ok, _} = ExTypesense.api_stats(context.conn) + test "health check with empty credentials" do + conn = %{api_key: nil, host: nil, port: nil, scheme: nil} + + assert_raise FunctionClauseError, fn -> + ExTypesense.health(conn) + end + end + + # test "health check, with incorrect API key" do + # conn = %{api_key: "abc", host: "localhost", port: 8109, scheme: "http"} + # assert {:ok, true} = ExTypesense.health(conn) + # end + + test "api status" do + assert {:ok, _} = ExTypesense.api_stats() end - test "cluster metrics", context do - assert {:ok, _} = ExTypesense.cluster_metrics(context.conn) + test "cluster metrics" do + assert {:ok, _} = ExTypesense.cluster_metrics() end end diff --git a/test/collection_test.exs b/test/collection_test.exs index 1cafe87..295435a 100644 --- a/test/collection_test.exs +++ b/test/collection_test.exs @@ -1,5 +1,5 @@ defmodule CollectionTest do - use ExUnit.Case, async: true + use ExUnit.Case, async: false setup_all do conn = %ExTypesense.Connection{ diff --git a/test/connection_test.exs b/test/connection_test.exs index 5d7d2bb..e5d7056 100644 --- a/test/connection_test.exs +++ b/test/connection_test.exs @@ -1,5 +1,5 @@ defmodule ConnectionTest do - use ExUnit.Case, async: true + use ExUnit.Case, async: false alias ExTypesense.TestSchema.Credential setup_all do diff --git a/test/document_test.exs b/test/document_test.exs index 95b0b1b..900dded 100644 --- a/test/document_test.exs +++ b/test/document_test.exs @@ -1,19 +1,17 @@ defmodule DocumentTest do - use ExUnit.Case, async: true + use ExUnit.Case, async: false alias ExTypesense.TestSchema.Person setup_all do - # this is for deprecated function to set the creds - [{:api_key, "xyz"}, {:host, "localhost"}, {:port, 8108}, {:scheme, "http"}] - |> Enum.each(fn {key, val} -> Application.put_env(:ex_typesense, key, val) end) - - conn = %ExTypesense.Connection{ - host: "localhost", - api_key: "xyz", - port: 8108, - scheme: "http" - } + Application.put_all_env( + ex_typesense: [ + api_key: "xyz", + host: "localhost", + port: 8108, + scheme: "http" + ] + ) schema = %{ name: "companies", diff --git a/test/search_test.exs b/test/search_test.exs index 323bc5a..26ea741 100644 --- a/test/search_test.exs +++ b/test/search_test.exs @@ -1,5 +1,5 @@ defmodule SearchTest do - use ExUnit.Case, async: true + use ExUnit.Case, async: false import Ecto.Query, warn: false alias ExTypesense.TestSchema.Person From b7f4c0b16527a0fc76c3f16118b1fbaf71ed16a0 Mon Sep 17 00:00:00 2001 From: jaeyson Date: Mon, 1 Jul 2024 01:21:04 +0800 Subject: [PATCH 3/5] setting application envs to test_helper.exs --- lib/ex_typesense.ex | 11 --- lib/ex_typesense/document.ex | 63 ------------ lib/ex_typesense/http_client.ex | 17 +++- lib/ex_typesense/test_schema/catalog.ex | 36 +++++++ test/cluster_test.exs | 42 +------- test/collection_test.exs | 100 ++++++++++--------- test/connection_test.exs | 70 +++++++++++--- test/document_test.exs | 123 ++++++++++-------------- test/search_test.exs | 58 ++++++----- test/test_helper.exs | 14 +++ 10 files changed, 250 insertions(+), 284 deletions(-) create mode 100644 lib/ex_typesense/test_schema/catalog.ex diff --git a/lib/ex_typesense.ex b/lib/ex_typesense.ex index b724a92..444b56f 100644 --- a/lib/ex_typesense.ex +++ b/lib/ex_typesense.ex @@ -87,19 +87,8 @@ defmodule ExTypesense do to: ExTypesense.Document defdelegate create_document(conn \\ Connection.new(), document), to: ExTypesense.Document - - @deprecated "use delete_document_by_id/3" defdelegate delete_document(document), to: ExTypesense.Document - - @deprecated "use delete_document_by_struct/2" defdelegate delete_document(collection_name, document_id), to: ExTypesense.Document - - defdelegate delete_document_by_struct(conn \\ Connection.new(), struct), - to: ExTypesense.Document - - defdelegate delete_document_by_id(conn \\ Connection.new(), collection_name, document_id), - to: ExTypesense.Document - defdelegate update_document(conn \\ Connection.new(), document), to: ExTypesense.Document defdelegate upsert_document(conn \\ Connection.new(), document), to: ExTypesense.Document diff --git a/lib/ex_typesense/document.ex b/lib/ex_typesense/document.ex index a6a66ff..268acbf 100644 --- a/lib/ex_typesense/document.ex +++ b/lib/ex_typesense/document.ex @@ -371,72 +371,10 @@ defmodule ExTypesense.Document do HttpClient.request(conn, opts) end - @doc """ - Deletes a document by struct. - """ - @doc since: "0.4.0" - @spec delete_document_by_struct(Connection.t(), struct()) :: response() - def delete_document_by_struct(conn \\ Connection.new(), struct) when is_struct(struct) do - document_id = struct.id - collection_name = struct.__struct__.__schema__(:source) - do_delete_document(conn, collection_name, document_id) - end - - @doc """ - Deletes a document by collection name and document id. - - ## Examples - iex> schema = %{ - ...> name: "posts", - ...> fields: [ - ...> %{name: "title", type: "string"} - ...> ], - ...> } - ...> ExTypesense.create_collection(schema) - iex> post = - ...> %{ - ...> id: "12", - ...> collection_name: "posts", - ...> post_id: 22, - ...> title: "the quick brown fox" - ...> } - iex> ExTypesense.create_document(post) - iex> ExTypesense.delete_document("posts", 12) - {:ok, - %{ - "id" => "12", - "post_id" => 22, - "title" => "the quick brown fox", - "collection_name" => "posts" - } - } - """ - @doc since: "0.4.0" - @spec delete_document_by_id(Connection.t(), String.t(), integer()) :: response() - def delete_document_by_id(conn \\ Connection.new(), collection_name, document_id) - when is_binary(collection_name) and is_integer(document_id) do - do_delete_document(conn, collection_name, document_id) - end - - @doc since: "0.4.0" - @spec do_delete_document(Connection.t(), String.t(), integer()) :: response() - defp do_delete_document(conn, collection_name, document_id) do - path = - Path.join([ - @collections_path, - collection_name, - @documents_path, - Jason.encode!(document_id) - ]) - - HttpClient.request(conn, %{method: :delete, path: path}) - end - @doc """ Deletes a document by struct. """ @doc since: "0.3.0" - @deprecated "use delete_document_by_struct/2" @spec delete_document(struct()) :: response() def delete_document(struct) when is_struct(struct) do document_id = struct.id @@ -474,7 +412,6 @@ defmodule ExTypesense.Document do } """ @doc since: "0.3.0" - @deprecated "use delete_document_by_id/3" @spec delete_document(String.t(), integer()) :: response() def delete_document(collection_name, document_id) when is_binary(collection_name) and is_integer(document_id) do diff --git a/lib/ex_typesense/http_client.ex b/lib/ex_typesense/http_client.ex index 7ed42a8..138e129 100644 --- a/lib/ex_typesense/http_client.ex +++ b/lib/ex_typesense/http_client.ex @@ -77,7 +77,22 @@ defmodule ExTypesense.HttpClient do @doc since: "0.4.0" @spec request(Connection.t(), map()) :: {:ok, any()} | {:error, String.t()} def request(conn, opts \\ %{}) do - retry = if opts[:retry], do: opts[:retry], else: &Req.Steps.retry/1 + # Req.Request.append_error_steps and its retry option are used here. + # options like retry, max_retries, etc. can be found in: + # https://hexdocs.pm/req/Req.Steps.html#retry/1 + # NOTE: look at source code in Github + retry = fn request -> + if Mix.env() === :test do + {req, resp_or_err} = request + + # disabled in order to cut time in tests + req = %{req | options: %{retry: false}} + + Req.Steps.retry({req, resp_or_err}) + else + Req.Steps.retry(request) + end + end url = %URI{ diff --git a/lib/ex_typesense/test_schema/catalog.ex b/lib/ex_typesense/test_schema/catalog.ex new file mode 100644 index 0000000..03f28a9 --- /dev/null +++ b/lib/ex_typesense/test_schema/catalog.ex @@ -0,0 +1,36 @@ +defmodule ExTypesense.TestSchema.Catalog do + use Ecto.Schema + @behaviour ExTypesense + + @moduledoc false + + defimpl Jason.Encoder, for: __MODULE__ do + def encode(value, opts) do + value + |> Map.take([:catalog_id, :name, :description]) + |> Enum.map(fn {key, val} -> + if key === :catalog_id, do: {key, Map.get(value, :id)}, else: {key, val} + end) + |> Enum.into(%{}) + |> Jason.Encode.map(opts) + end + end + + schema "catalogs" do + field(:name, :string) + field(:description, :string) + field(:catalog_id, :integer, virtual: true) + end + + @impl ExTypesense + def get_field_types do + %{ + default_sorting_field: "catalog_id", + fields: [ + %{name: "catalog_id", type: "int32"}, + %{name: "name", type: "string"}, + %{name: "description", type: "string"} + ] + } + end +end diff --git a/test/cluster_test.exs b/test/cluster_test.exs index 9b0dcfb..10fddf2 100644 --- a/test/cluster_test.exs +++ b/test/cluster_test.exs @@ -1,48 +1,10 @@ defmodule ClusterTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true - setup_all do - Application.put_all_env( - ex_typesense: [ - api_key: "xyz", - host: "localhost", - port: 8108, - scheme: "http" - ] - ) - - on_exit(fn -> - # this is for deprecated function to set the creds - [:api_key, :host, :port, :scheme] - |> Enum.each(&Application.delete_env(:ex_typesense, &1)) - end) - - :ok - end - - test "health", context do + test "health" do assert {:ok, true} = ExTypesense.health() - # assert_raise FunctionClauseError, fn -> - # ExTypesense.health() - # end - # assert_raise FunctionClauseError, fn -> - # Enum.chunk([1, 2, 3], 0) - # end end - test "health check with empty credentials" do - conn = %{api_key: nil, host: nil, port: nil, scheme: nil} - - assert_raise FunctionClauseError, fn -> - ExTypesense.health(conn) - end - end - - # test "health check, with incorrect API key" do - # conn = %{api_key: "abc", host: "localhost", port: 8109, scheme: "http"} - # assert {:ok, true} = ExTypesense.health(conn) - # end - test "api status" do assert {:ok, _} = ExTypesense.api_stats() end diff --git a/test/collection_test.exs b/test/collection_test.exs index 295435a..836e3bd 100644 --- a/test/collection_test.exs +++ b/test/collection_test.exs @@ -1,16 +1,9 @@ defmodule CollectionTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true setup_all do - conn = %ExTypesense.Connection{ - host: "localhost", - api_key: "xyz", - port: 8108, - scheme: "http" - } - schema = %{ - name: "companies", + name: "collection_companies", fields: [ %{name: "company_name", type: "string"}, %{name: "company_id", type: "int32"}, @@ -19,23 +12,27 @@ defmodule CollectionTest do default_sorting_field: "company_id" } - %{conn: conn, schema: schema} + on_exit(fn -> + ExTypesense.drop_collection(schema.name) + end) + + %{schema: schema} end - test "success: create and drop collection", %{conn: conn, schema: schema} do - collection = ExTypesense.create_collection(conn, schema) + test "success: create and drop collection", %{schema: schema} do + collection = ExTypesense.create_collection(schema) assert %ExTypesense.Collection{} = collection - ExTypesense.drop_collection(conn, schema.name) - assert {:error, "Not Found"} === ExTypesense.get_collection(conn, schema.name) + ExTypesense.drop_collection(schema.name) + assert {:error, "Not Found"} === ExTypesense.get_collection(schema.name) end - test "error: dropping unknown collection", %{conn: conn, schema: schema} do + test "error: dropping unknown collection", %{schema: schema} do message = ~s(No collection with name `#{schema.name}` found.) - assert {:error, message} === ExTypesense.drop_collection(conn, schema.name) + assert {:error, message} === ExTypesense.drop_collection(schema.name) end - test "success: get specific collection", %{conn: conn} do + test "success: get specific collection" do schema = %{ name: "specific_collection", fields: [ @@ -45,18 +42,18 @@ defmodule CollectionTest do default_sorting_field: "collection_id" } - assert %ExTypesense.Collection{} = ExTypesense.create_collection(conn, schema) - collection = ExTypesense.get_collection(conn, schema.name) + assert %ExTypesense.Collection{} = ExTypesense.create_collection(schema) + collection = ExTypesense.get_collection(schema.name) assert collection.name === schema.name - ExTypesense.drop_collection(conn, schema.name) + ExTypesense.drop_collection(schema.name) end - test "error: get unknown collection", %{conn: conn, schema: schema} do - assert {:error, "Not Found"} === ExTypesense.get_collection(conn, schema.name) + test "error: get unknown collection", %{schema: schema} do + assert {:error, "Not Found"} === ExTypesense.get_collection(schema.name) end - test "success: update schema fields", %{conn: conn, schema: schema} do - ExTypesense.create_collection(conn, schema) + test "success: update schema fields", %{schema: schema} do + ExTypesense.create_collection(schema) fields = %{ fields: [ @@ -65,67 +62,68 @@ defmodule CollectionTest do ] } - ExTypesense.update_collection_fields(conn, schema.name, fields) + ExTypesense.update_collection_fields(schema.name, fields) - collection = ExTypesense.get_collection(conn, schema.name) + collection = ExTypesense.get_collection(schema.name) test = Enum.find(collection.fields, fn map -> map["name"] === "test" end) assert test["name"] === "test" - ExTypesense.drop_collection(conn, schema.name) + ExTypesense.drop_collection(schema.name) end + # ISSUE: https://github.com/typesense/typesense/issues/1700 # test "success: update collection name" do # end - test "success: count list of collections", %{conn: conn, schema: schema} do - ExTypesense.create_collection(conn, schema) - refute ExTypesense.list_collections(conn) |> Enum.empty?() - ExTypesense.drop_collection(conn, schema.name) + test "success: count list of collections", %{schema: schema} do + ExTypesense.create_collection(schema) + refute ExTypesense.list_collections() |> Enum.empty?() + ExTypesense.drop_collection(schema.name) end - test "success: list aliases", %{conn: conn, schema: schema} do - ExTypesense.upsert_collection_alias(conn, schema.name, schema.name) - count = length(ExTypesense.list_collection_aliases(conn)) + test "success: list aliases", %{schema: schema} do + ExTypesense.upsert_collection_alias(schema.name, schema.name) + count = length(ExTypesense.list_collection_aliases()) assert count === 1 - ExTypesense.delete_collection_alias(conn, schema.name) + ExTypesense.delete_collection_alias(schema.name) end - test "success: create and delete alias", %{conn: conn, schema: schema} do - collection_alias = ExTypesense.upsert_collection_alias(conn, schema.name, schema.name) + test "success: create and delete alias", %{schema: schema} do + collection_alias = ExTypesense.upsert_collection_alias(schema.name, schema.name) assert is_map(collection_alias) === true assert Enum.empty?(collection_alias) === false - ExTypesense.delete_collection_alias(conn, schema.name) - assert {:error, "Not Found"} === ExTypesense.get_collection_alias(conn, schema.name) + ExTypesense.delete_collection_alias(schema.name) + assert {:error, "Not Found"} === ExTypesense.get_collection_alias(schema.name) end - test "success: get collection name by alias", %{conn: conn, schema: schema} do + test "success: get collection name by alias", %{schema: schema} do %{"collection_name" => collection_name, "name" => collection_alias} = - ExTypesense.upsert_collection_alias(conn, schema.name, schema.name) + ExTypesense.upsert_collection_alias(schema.name, schema.name) - assert collection_name === ExTypesense.get_collection_name(conn, collection_alias) + assert collection_name === ExTypesense.get_collection_name(collection_alias) - ExTypesense.delete_collection_alias(conn, schema.name) + ExTypesense.delete_collection_alias(schema.name) end - test "success: get specific alias", %{conn: conn, schema: schema} do - ExTypesense.upsert_collection_alias(conn, schema.name, schema.name) - collection_alias = ExTypesense.get_collection_alias(conn, schema.name) + test "success: get specific alias", %{schema: schema} do + ExTypesense.upsert_collection_alias(schema.name, schema.name) + collection_alias = ExTypesense.get_collection_alias(schema.name) assert is_map(collection_alias) assert collection_alias["name"] === schema.name - ExTypesense.delete_collection_alias(conn, schema.name) + ExTypesense.delete_collection_alias(schema.name) end - test "error: get unknown alias", %{conn: conn, schema: schema} do - assert {:error, "Not Found"} === ExTypesense.get_collection_alias(conn, schema.name) + test "error: get unknown alias", %{schema: schema} do + assert {:error, "Not Found"} === ExTypesense.get_collection_alias(schema.name) end - test "error: delete unknown alias", %{conn: conn, schema: schema} do - assert {:error, "Not Found"} === ExTypesense.delete_collection_alias(conn, schema.name) + test "error: delete unknown alias", %{schema: schema} do + assert {:error, "Not Found"} === ExTypesense.delete_collection_alias(schema.name) end end diff --git a/test/connection_test.exs b/test/connection_test.exs index e5d7056..b9ce7ad 100644 --- a/test/connection_test.exs +++ b/test/connection_test.exs @@ -1,34 +1,76 @@ defmodule ConnectionTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true alias ExTypesense.TestSchema.Credential + @forbidden "Forbidden - a valid `x-typesense-api-key` header must be sent." + setup_all do - %{ - conn: %ExTypesense.Connection{ - host: "localhost", - api_key: "xyz", - port: 8108, - scheme: "http" - } + schema = %{ + name: "connection_companies", + fields: [ + %{name: "company_name", type: "string"}, + %{name: "company_id", type: "int32"}, + %{name: "country", type: "string"} + ], + default_sorting_field: "company_id" } + + %{schema: schema} end - test "Using connection struct", context do - assert {:ok, true} = ExTypesense.health(context.conn) + setup %{schema: schema} do + ExTypesense.create_collection(schema) + + on_exit(fn -> + ExTypesense.drop_collection(schema.name) + end) + + :ok end - test "Using map" do + test "error: health check with empty credentials" do + conn = %{api_key: nil, host: nil, port: nil, scheme: nil} + + assert_raise FunctionClauseError, fn -> + ExTypesense.health(conn) + end + end + + test "error: health check, with incorrect API key" do + conn = %{api_key: "abc", host: "localhost", port: 8109, scheme: "http"} + + assert_raise Req.TransportError, fn -> + ExTypesense.health(conn) + end + end + + test "error: wrong API key was configured" do conn = %{ host: "localhost", - api_key: "xyz", + api_key: "another_key", port: 8108, scheme: "http" } - assert {:ok, true} = ExTypesense.health(conn) + assert {:error, @forbidden} == ExTypesense.list_collections(conn) + end + + test "error: overriding config with a wrong API key" do + conn = %{ + host: "localhost", + api_key: "another_key", + port: 8108, + scheme: "http" + } + + assert {:error, @forbidden} = ExTypesense.list_collections(conn) + end + + test "success: health check" do + assert {:ok, true} = ExTypesense.health() end - test "Using a struct converted to map and update its keys" do + test "success: Using a struct converted to map and update its keys" do conn = %Credential{ node: "localhost", secret_key: "xyz", diff --git a/test/document_test.exs b/test/document_test.exs index 900dded..ef63716 100644 --- a/test/document_test.exs +++ b/test/document_test.exs @@ -1,20 +1,11 @@ defmodule DocumentTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true alias ExTypesense.TestSchema.Person setup_all do - Application.put_all_env( - ex_typesense: [ - api_key: "xyz", - host: "localhost", - port: 8108, - scheme: "http" - ] - ) - schema = %{ - name: "companies", + name: "doc_companies", fields: [ %{name: "company_name", type: "string"}, %{name: "company_id", type: "int32"}, @@ -24,14 +15,14 @@ defmodule DocumentTest do } document = %{ - collection_name: "companies", + collection_name: "doc_companies", company_name: "Test", company_id: 1001, country: "US" } multiple_documents = %{ - collection_name: "companies", + collection_name: "doc_companies", documents: [ %{ company_name: "Industrial Mills, Co.", @@ -46,49 +37,44 @@ defmodule DocumentTest do ] } - ExTypesense.create_collection(conn, schema) - ExTypesense.create_collection(conn, Person) + %{schema: schema, document: document, multiple_documents: multiple_documents} + end + + setup %{schema: schema} do + ExTypesense.create_collection(schema) + ExTypesense.create_collection(Person) on_exit(fn -> - ExTypesense.drop_collection(conn, schema.name) - ExTypesense.drop_collection(conn, Person) - # from doctest - ExTypesense.drop_collection(conn, "posts") - - # this is for deprecated function to set the creds - [:api_key, :host, :port, :scheme] - |> Enum.each(&Application.delete_env(:ex_typesense, &1)) + ExTypesense.drop_collection(schema.name) + ExTypesense.drop_collection(Person) end) - %{conn: conn, schema: schema, document: document, multiple_documents: multiple_documents} + :ok end - test "error: get unknown document", %{conn: conn, schema: schema} do + test "error: get unknown document", %{schema: schema} do unknown_id = 999 message = ~s(Could not find a document with id: #{unknown_id}) - assert {:error, message} === ExTypesense.get_document(conn, schema.name, unknown_id) + assert {:error, message} === ExTypesense.get_document(schema.name, unknown_id) end - test "success: index a document using a map then fetch if indexed", %{ - conn: conn, - document: document - } do + test "success: index a document using a map then fetch if indexed", %{document: document} do {:ok, %{"id" => id, "company_name" => company_name}} = - ExTypesense.create_document(conn, document) + ExTypesense.create_document(document) id = String.to_integer(id) - {:ok, result} = ExTypesense.get_document(conn, "companies", id) + {:ok, result} = ExTypesense.get_document("doc_companies", id) assert result["company_name"] === company_name end - test "success: adding unknown field", %{conn: conn, document: document} do + test "success: adding unknown field", %{document: document} do document = Map.put(document, :unknown_field, "unknown_value") - {:ok, collection} = ExTypesense.create_document(conn, document) + {:ok, collection} = ExTypesense.create_document(document) assert Map.has_key?(collection, "unknown_field") end - test "success: upsert to update a document", %{conn: conn, document: document} do - {:ok, %{"id" => id}} = ExTypesense.create_document(conn, document) + test "success: upsert to update a document", %{document: document} do + {:ok, %{"id" => id}} = ExTypesense.create_document(document) id = String.to_integer(id) company_name = "Stark Industries" @@ -97,25 +83,25 @@ defmodule DocumentTest do |> Map.put(:company_name, company_name) |> Map.put(:id, id) - {:ok, result} = ExTypesense.upsert_document(conn, updated_document) + {:ok, result} = ExTypesense.upsert_document(updated_document) assert company_name === result["company_name"] end - test "success: create document using upsert_document/2", %{conn: conn, document: document} do + test "success: create document using upsert_document/2", %{document: document} do document = Map.put(document, :id, "9999") - assert {:ok, %{"id" => "9999"}} = ExTypesense.upsert_document(conn, document) + assert {:ok, %{"id" => "9999"}} = ExTypesense.upsert_document(document) end - test "error: creates a document with a specific id twice", %{conn: conn, document: document} do + test "error: creates a document with a specific id twice", %{document: document} do document = Map.put(document, :id, "99") - assert {:ok, %{"id" => id}} = ExTypesense.create_document(conn, document) - assert {:error, message} = ExTypesense.create_document(conn, document) + assert {:ok, %{"id" => id}} = ExTypesense.create_document(document) + assert {:error, message} = ExTypesense.create_document(document) assert message === "A document with id #{id} already exists." end - test "success: update a document", %{conn: conn, document: document} do - {:ok, %{"id" => id}} = ExTypesense.create_document(conn, document) + test "success: update a document", %{document: document} do + {:ok, %{"id" => id}} = ExTypesense.create_document(document) company_name = "Stark Industries" updated_document = @@ -123,46 +109,39 @@ defmodule DocumentTest do |> Map.put(:company_name, company_name) |> Map.put(:id, id) - {:ok, result} = ExTypesense.update_document(conn, updated_document) + {:ok, result} = ExTypesense.update_document(updated_document) assert company_name === result["company_name"] end - test "success: (deprecate) deletes a document using map", %{conn: conn, document: document} do - {:ok, %{"id" => id}} = ExTypesense.create_document(conn, document) + test "success: deletes a document using map", %{document: document} do + {:ok, %{"id" => id}} = ExTypesense.create_document(document) assert {:ok, _} = ExTypesense.delete_document(document.collection_name, String.to_integer(id)) end - test "success: deletes a document by struct", %{conn: conn} do - person = %Person{id: 0, name: "Tar Zan", person_id: 0, country: "Brazil"} + test "success: deletes a document by struct" do + person = %Person{id: 0, name: "John Smith", person_id: 0, country: "Brazil"} - assert {:ok, %{"country" => "Brazil", "id" => "0", "name" => "Tar Zan", "person_id" => 0}} = - ExTypesense.create_document(conn, person) + assert {:ok, %{"country" => "Brazil", "id" => "0", "name" => "John Smith", "person_id" => 0}} = + ExTypesense.create_document(person) - assert {:ok, _} = ExTypesense.delete_document_by_struct(conn, person) + assert {:ok, _} = ExTypesense.delete_document(person) end - test "success: deletes a document by id", %{conn: conn, document: document} do - {:ok, %{"id" => id}} = ExTypesense.create_document(conn, document) + test "success: deletes a document by id", %{document: document} do + {:ok, %{"id" => id}} = ExTypesense.create_document(document) - assert {:ok, _} = - ExTypesense.delete_document_by_id( - conn, - document.collection_name, - String.to_integer(id) - ) + assert {:ok, _} = ExTypesense.delete_document(document.collection_name, String.to_integer(id)) end - test "success: index multiple documents", %{conn: conn, multiple_documents: multiple_documents} do - conn - |> ExTypesense.index_multiple_documents(multiple_documents) + test "success: index multiple documents", %{multiple_documents: multiple_documents} do + ExTypesense.index_multiple_documents(multiple_documents) |> Kernel.===({:ok, [%{"success" => true}, %{"success" => true}]}) |> assert() end test "success: update multiple documents", %{ - conn: conn, multiple_documents: multiple_documents, schema: schema } do @@ -171,8 +150,8 @@ defmodule DocumentTest do first_update = "first_update" second_update = "second_update" - {:ok, %{"id" => first_id}} = ExTypesense.create_document(conn, first) - {:ok, %{"id" => second_id}} = ExTypesense.create_document(conn, second) + {:ok, %{"id" => first_id}} = ExTypesense.create_document(first) + {:ok, %{"id" => second_id}} = ExTypesense.create_document(second) update_1 = first @@ -186,21 +165,19 @@ defmodule DocumentTest do multiple_documents = Map.put(multiple_documents, :documents, [update_1, update_2]) - conn - |> ExTypesense.update_multiple_documents(multiple_documents) + ExTypesense.update_multiple_documents(multiple_documents) |> Kernel.===({:ok, [%{"success" => true}, %{"success" => true}]}) |> assert() - {:ok, first} = ExTypesense.get_document(conn, schema.name, String.to_integer(first_id)) - {:ok, second} = ExTypesense.get_document(conn, schema.name, String.to_integer(second_id)) + {:ok, first} = ExTypesense.get_document(schema.name, String.to_integer(first_id)) + {:ok, second} = ExTypesense.get_document(schema.name, String.to_integer(second_id)) assert first["company_name"] === first_update assert second["company_name"] === second_update end - test "success: upsert multiple documents", %{conn: conn, multiple_documents: multiple_documents} do - conn - |> ExTypesense.upsert_multiple_documents(multiple_documents) + test "success: upsert multiple documents", %{multiple_documents: multiple_documents} do + ExTypesense.upsert_multiple_documents(multiple_documents) |> Kernel.===({:ok, [%{"success" => true}, %{"success" => true}]}) |> assert() end diff --git a/test/search_test.exs b/test/search_test.exs index 26ea741..a5577ef 100644 --- a/test/search_test.exs +++ b/test/search_test.exs @@ -1,18 +1,12 @@ defmodule SearchTest do - use ExUnit.Case, async: false + use ExUnit.Case, async: true import Ecto.Query, warn: false - alias ExTypesense.TestSchema.Person - setup_all do - conn = %ExTypesense.Connection{ - host: "localhost", - api_key: "xyz", - port: 8108, - scheme: "http" - } + alias ExTypesense.TestSchema.Catalog + setup_all do schema = %{ - name: "companies", + name: "search_companies", fields: [ %{name: "company_name", type: "string"}, %{name: "company_id", type: "int32"}, @@ -22,58 +16,60 @@ defmodule SearchTest do } document = %{ - collection_name: "companies", + collection_name: "search_companies", company_name: "Test", company_id: 1001, country: "US" } - person = %Person{ + catalog = %Catalog{ id: 1002, - name: "John Smith", - country: "UK", - person_id: 1002 + name: "Rubber Ducky", + description: "A tool by articulating a problem in spoken or written natural language.", + catalog_id: 1002 } - ExTypesense.create_collection(conn, schema) - ExTypesense.create_collection(conn, Person) + with %ExTypesense.Collection{} <- ExTypesense.create_collection(schema) do + {:ok, _} = ExTypesense.create_document(document) + end - {:ok, _} = ExTypesense.create_document(conn, document) - {:ok, _} = ExTypesense.create_document(conn, person) + with %ExTypesense.Collection{} <- ExTypesense.create_collection(Catalog) do + {:ok, _} = ExTypesense.create_document(catalog) + end on_exit(fn -> - ExTypesense.drop_collection(conn, schema.name) - ExTypesense.drop_collection(conn, Person) + ExTypesense.drop_collection(schema.name) + ExTypesense.drop_collection(Catalog) end) - %{conn: conn, schema: schema, document: document, person: person} + %{schema: schema, document: document, catalog: catalog} end - test "success: search with result", %{conn: conn, schema: schema} do + test "success: search with result", %{schema: schema} do params = %{ q: "test", query_by: "company_name" } - assert {:ok, _} = ExTypesense.search(conn, schema.name, params) + assert {:ok, _} = ExTypesense.search(schema.name, params) end - test "success: search with Ecto", %{conn: conn, person: person} do + test "success: search with Ecto", %{catalog: catalog} do params = %{ - q: "UK", - query_by: "country" + q: "duck", + query_by: "name" } - assert %Ecto.Query{} = Person |> where([p], p.id in ^[person.person_id]) - assert %Ecto.Query{} = ExTypesense.search(conn, Person, params) + assert %Ecto.Query{} = Catalog |> where([p], p.id in ^[catalog.catalog_id]) + assert %Ecto.Query{} = ExTypesense.search(Catalog, params) end - test "success: empty result", %{conn: conn, schema: schema} do + test "success: empty result", %{schema: schema} do params = %{ q: "unknown", query_by: "company_name" } - assert {:ok, _} = ExTypesense.search(conn, schema.name, params) + assert {:ok, %{"found" => 0, "hits" => []}} = ExTypesense.search(schema.name, params) end end diff --git a/test/test_helper.exs b/test/test_helper.exs index 869559e..cfc20f1 100644 --- a/test/test_helper.exs +++ b/test/test_helper.exs @@ -1 +1,15 @@ +Application.put_all_env( + ex_typesense: [ + api_key: "xyz", + host: "localhost", + port: 8108, + scheme: "http" + ] +) + ExUnit.start() + +ExUnit.after_suite(fn %{failures: 0, skipped: 0, excluded: 0} -> + [:api_key, :host, :port, :scheme] + |> Enum.each(&Application.delete_env(:ex_typesense, &1)) +end) From f8b99ae3eb8ec66f3af9a9ee14494b654505134a Mon Sep 17 00:00:00 2001 From: jaeyson Date: Mon, 1 Jul 2024 01:30:10 +0800 Subject: [PATCH 4/5] update README for custom connection --- README.md | 24 +++++------------------- 1 file changed, 5 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index 0be9258..876fc75 100644 --- a/README.md +++ b/README.md @@ -76,12 +76,12 @@ config :ex_typesense, scheme: "https" ``` -#### Option 2: Dynamic connection using an Ecto schema +#### Option 2: Set credentials from a map > By default you don't need to pass connections every > time you use a function, if you use "Option 1" above. -You may have a `Connection` Ecto schema in your app and want to pass your own creds dynamically. +You may have a `Connection` Ecto schema in your app and want to pass your own creds dynamically: ```elixir defmodule MyApp.Credential do @@ -93,24 +93,11 @@ defmodule MyApp.Credential do end ``` -using Connection struct +As long as the keys matches in `ExTypesense.Connection.t()`: ```elixir credential = MyApp.Credential |> where(id: ^8888) |> Repo.one() -conn = %ExTypesense.Connection{ - host: credential.node, - api_key: credential.secret_key, - port: credential.port, - scheme: "https" -} - -ExTypesense.search(conn, collection_name, query) -``` - -or maps, as long as the keys matches in `ExTypesense.Connection.t()` - -```elixir conn = %{ host: credential.node, api_key: credential.secret_key, @@ -119,10 +106,9 @@ conn = %{ } ExTypesense.search(conn, collection_name, query) - ``` -or convert your struct to map, as long as the keys matches in `ExTypesense.Connection.t()` +Or convert your struct to map, as long as the keys matches in `ExTypesense.Connection.t()`: ```elixir conn = Map.from_struct(MyApp.Credential) @@ -131,7 +117,7 @@ ExTypesense.search(conn, collection_name, query) ``` -or you don't want to change the fields in your schema, thus you convert it to map +Or you don't want to change the fields in your Ecto schema, thus you convert it to map: ```elixir conn = %Credential{ From 203dbd93147ecea284f97c57114aa843f536e1ed Mon Sep 17 00:00:00 2001 From: jaeyson Date: Thu, 4 Jul 2024 00:37:48 +0800 Subject: [PATCH 5/5] update version number --- CHANGELOG.md | 7 +++++++ mix.exs | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index af3eb31..be8df2e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## 0.4.3 (2024.07.03) + +### Changed + +* `README` regarding test and connection strings. +* Replacing connection struct to map. + ## 0.4.2 (2024.06.19) ### Changed diff --git a/mix.exs b/mix.exs index 7cdd8d0..edebc77 100644 --- a/mix.exs +++ b/mix.exs @@ -2,7 +2,7 @@ defmodule ExTypesense.MixProject do use Mix.Project @source_url "https://github.com/jaeyson/ex_typesense" - @version "0.4.2" + @version "0.4.3" def project do [