10 |
11 |
12 | <%= for todo_item <- @todo_items do %>
13 |
14 |
<%= todo_item.item %>
15 |
16 |
17 | <%= link "Show", to: Routes.todo_item_path(@conn, :show, todo_item) %>
18 | <%= link "Edit", to: Routes.todo_item_path(@conn, :edit, todo_item) %>
19 | <%= link "Delete", to: Routes.todo_item_path(@conn, :delete, todo_item), method: :delete, data: [confirm: "Are you sure?"] %>
20 |
21 |
22 | <% end %>
23 |
24 |
25 |
26 | <%= link "New Todo item", to: Routes.todo_item_path(@conn, :new) %>
27 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/templates/todo_item/new.html.heex:
--------------------------------------------------------------------------------
1 |
24 | <%= link "Log in", to: Routes.user_session_path(@conn, :new) %> |
25 | <%= link "Forgot your password?", to: Routes.user_reset_password_path(@conn, :new) %>
26 |
25 | <%= link "Register", to: Routes.user_registration_path(@conn, :new) %> |
26 | <%= link "Forgot your password?", to: Routes.user_reset_password_path(@conn, :new) %>
27 |
53 |
54 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.ErrorHelpers do
2 | @moduledoc """
3 | Conveniences for translating and building error messages.
4 | """
5 |
6 | use Phoenix.HTML
7 |
8 | @doc """
9 | Generates tag for inlined form input errors.
10 | """
11 | def error_tag(form, field) do
12 | Enum.map(Keyword.get_values(form.errors, field), fn error ->
13 | content_tag(:span, translate_error(error),
14 | class: "invalid-feedback",
15 | phx_feedback_for: input_name(form, field)
16 | )
17 | end)
18 | end
19 |
20 | @doc """
21 | Translates an error message using gettext.
22 | """
23 | def translate_error({msg, opts}) do
24 | # When using gettext, we typically pass the strings we want
25 | # to translate as a static argument:
26 | #
27 | # # Translate "is invalid" in the "errors" domain
28 | # dgettext("errors", "is invalid")
29 | #
30 | # # Translate the number of files with plural rules
31 | # dngettext("errors", "1 file", "%{count} files", count)
32 | #
33 | # Because the error messages we show in our forms and APIs
34 | # are defined inside Ecto, we need to translate them dynamically.
35 | # This requires us to call the Gettext module passing our gettext
36 | # backend as first argument.
37 | #
38 | # Note we use the "errors" domain, which means translations
39 | # should be written to the errors.po file. The :count option is
40 | # set by Ecto and indicates we should also apply plural rules.
41 | if count = opts[:count] do
42 | Gettext.dngettext(SqliteScaleWeb.Gettext, "errors", msg, msg, count, opts)
43 | else
44 | Gettext.dgettext(SqliteScaleWeb.Gettext, "errors", msg, opts)
45 | end
46 | end
47 | end
48 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/error_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.ErrorView do
2 | use SqliteScaleWeb, :view
3 |
4 | # If you want to customize a particular status code
5 | # for a certain format, you may uncomment below.
6 | # def render("500.html", _assigns) do
7 | # "Internal Server Error"
8 | # end
9 |
10 | # By default, Phoenix returns the status message from
11 | # the template name. For example, "404.html" becomes
12 | # "Not Found".
13 | def template_not_found(template, _assigns) do
14 | Phoenix.Controller.status_message_from_template(template)
15 | end
16 | end
17 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.LayoutView do
2 | use SqliteScaleWeb, :view
3 |
4 | # Phoenix LiveDashboard is available only in development by default,
5 | # so we instruct Elixir to not warn if the dashboard route is missing.
6 | @compile {:no_warn_undefined, {Routes, :live_dashboard_path, 2}}
7 | end
8 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.PageView do
2 | use SqliteScaleWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/todo_item_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.TodoItemView do
2 | use SqliteScaleWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/user_confirmation_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserConfirmationView do
2 | use SqliteScaleWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/user_registration_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserRegistrationView do
2 | use SqliteScaleWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/user_reset_password_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserResetPasswordView do
2 | use SqliteScaleWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/user_session_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserSessionView do
2 | use SqliteScaleWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/lib/sqlite_scale_web/views/user_settings_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserSettingsView do
2 | use SqliteScaleWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScale.MixProject do
2 | use Mix.Project
3 |
4 | def project do
5 | [
6 | app: :sqlite_scale,
7 | version: "0.1.0",
8 | elixir: "~> 1.12",
9 | elixirc_paths: elixirc_paths(Mix.env()),
10 | compilers: [:gettext] ++ Mix.compilers(),
11 | start_permanent: Mix.env() == :prod,
12 | aliases: aliases(),
13 | deps: deps()
14 | ]
15 | end
16 |
17 | # Configuration for the OTP application.
18 | #
19 | # Type `mix help compile.app` for more information.
20 | def application do
21 | [
22 | mod: {SqliteScale.Application, []},
23 | extra_applications: [:logger, :runtime_tools]
24 | ]
25 | end
26 |
27 | # Specifies which paths to compile per environment.
28 | defp elixirc_paths(:test), do: ["lib", "test/support"]
29 | defp elixirc_paths(_), do: ["lib"]
30 |
31 | # Specifies your project dependencies.
32 | #
33 | # Type `mix help deps` for examples and options.
34 | defp deps do
35 | [
36 | {:bcrypt_elixir, "~> 2.0"},
37 | {:phoenix, "~> 1.6.6"},
38 | {:phoenix_ecto, "~> 4.4"},
39 | {:ecto_sql, "~> 3.6"},
40 | {:ecto_sqlite3, ">= 0.0.0"},
41 | {:phoenix_html, "~> 3.0"},
42 | {:phoenix_live_reload, "~> 1.2", only: :dev},
43 | {:phoenix_live_view, "~> 0.17.5"},
44 | {:floki, ">= 0.30.0", only: :test},
45 | {:phoenix_live_dashboard, "~> 0.6"},
46 | {:esbuild, "~> 0.3", runtime: Mix.env() == :dev},
47 | {:swoosh, "~> 1.3"},
48 | {:telemetry_metrics, "~> 0.6"},
49 | {:telemetry_poller, "~> 1.0"},
50 | {:gettext, "~> 0.18"},
51 | {:jason, "~> 1.2"},
52 | {:plug_cowboy, "~> 2.5"}
53 | ]
54 | end
55 |
56 | # Aliases are shortcuts or tasks specific to the current project.
57 | # For example, to install project dependencies and perform other setup tasks, run:
58 | #
59 | # $ mix setup
60 | #
61 | # See the documentation for `Mix` for more info on aliases.
62 | defp aliases do
63 | [
64 | setup: ["deps.get", "ecto.setup"],
65 | "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
66 | "ecto.reset": ["ecto.drop", "ecto.setup"],
67 | test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"],
68 | "assets.deploy": ["esbuild default --minify", "phx.digest"]
69 | ]
70 | end
71 | end
72 |
--------------------------------------------------------------------------------
/mix.lock:
--------------------------------------------------------------------------------
1 | %{
2 | "bcrypt_elixir": {:hex, :bcrypt_elixir, "2.3.1", "5114d780459a04f2b4aeef52307de23de961b69e13a5cd98a911e39fda13f420", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "42182d5f46764def15bf9af83739e3bf4ad22661b1c34fc3e88558efced07279"},
3 | "castore": {:hex, :castore, "0.1.15", "dbb300827d5a3ec48f396ca0b77ad47058578927e9ebe792abd99fcbc3324326", [:mix], [], "hexpm", "c69379b907673c7e6eb229f09a0a09b60bb27cfb9625bcb82ea4c04ba82a8442"},
4 | "comeonin": {:hex, :comeonin, "5.3.3", "2c564dac95a35650e9b6acfe6d2952083d8a08e4a89b93a481acb552b325892e", [:mix], [], "hexpm", "3e38c9c2cb080828116597ca8807bb482618a315bfafd98c90bc22a821cc84df"},
5 | "connection": {:hex, :connection, "1.1.0", "ff2a49c4b75b6fb3e674bfc5536451607270aac754ffd1bdfe175abe4a6d7a68", [:mix], [], "hexpm", "722c1eb0a418fbe91ba7bd59a47e28008a189d47e37e0e7bb85585a016b2869c"},
6 | "cowboy": {:hex, :cowboy, "2.9.0", "865dd8b6607e14cf03282e10e934023a1bd8be6f6bacf921a7e2a96d800cd452", [:make, :rebar3], [{:cowlib, "2.11.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "2c729f934b4e1aa149aff882f57c6372c15399a20d54f65c8d67bef583021bde"},
7 | "cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"},
8 | "cowlib": {:hex, :cowlib, "2.11.0", "0b9ff9c346629256c42ebe1eeb769a83c6cb771a6ee5960bd110ab0b9b872063", [:make, :rebar3], [], "hexpm", "2b3e9da0b21c4565751a6d4901c20d1b4cc25cbb7fd50d91d2ab6dd287bc86a9"},
9 | "db_connection": {:hex, :db_connection, "2.4.1", "6411f6e23f1a8b68a82fa3a36366d4881f21f47fc79a9efb8c615e62050219da", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ea36d226ec5999781a9a8ad64e5d8c4454ecedc7a4d643e4832bf08efca01f00"},
10 | "decimal": {:hex, :decimal, "2.0.0", "a78296e617b0f5dd4c6caf57c714431347912ffb1d0842e998e9792b5642d697", [:mix], [], "hexpm", "34666e9c55dea81013e77d9d87370fe6cb6291d1ef32f46a1600230b1d44f577"},
11 | "ecto": {:hex, :ecto, "3.7.1", "a20598862351b29f80f285b21ec5297da1181c0442687f9b8329f0445d228892", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "d36e5b39fc479e654cffd4dbe1865d9716e4a9b6311faff799b6f90ab81b8638"},
12 | "ecto_sql": {:hex, :ecto_sql, "3.7.2", "55c60aa3a06168912abf145c6df38b0295c34118c3624cf7a6977cd6ce043081", [:mix], [{:db_connection, "~> 2.2", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.7.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.4.0 or ~> 0.5.0 or ~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.15.0 or ~> 0.16.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3c218ea62f305dcaef0b915fb56583195e7b91c91dcfb006ba1f669bfacbff2a"},
13 | "ecto_sqlite3": {:hex, :ecto_sqlite3, "0.7.3", "119e5142f23b9868ac17449cd945557897c18f30c0b39e3eb96659729d38310e", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ecto, "~> 3.7", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "~> 3.7", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:exqlite, "~> 0.9", [hex: :exqlite, repo: "hexpm", optional: false]}], "hexpm", "5a149b96e6c2e2ebcca60d23cbcf89130f7fbbcdba62956a70aa3d6d002a8e54"},
14 | "elixir_make": {:hex, :elixir_make, "0.6.3", "bc07d53221216838d79e03a8019d0839786703129599e9619f4ab74c8c096eac", [:mix], [], "hexpm", "f5cbd651c5678bcaabdbb7857658ee106b12509cd976c2c2fca99688e1daf716"},
15 | "esbuild": {:hex, :esbuild, "0.4.0", "9f17db148aead4cf1e6e6a584214357287a93407b5fb51a031f122b61385d4c2", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}], "hexpm", "b61e4e6b92ffe45e4ee4755a22de6211a67c67987dc02afb35a425a0add1d447"},
16 | "exqlite": {:hex, :exqlite, "0.9.3", "57c80e742584dc4486d717681956d4152c7d03fb34ddbfb269844b504824528d", [:make, :mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "5108f84bcc91fd7ae5b1b247e2be3860e449de5f8383ccaa1454278ffa1fc509"},
17 | "file_system": {:hex, :file_system, "0.2.10", "fb082005a9cd1711c05b5248710f8826b02d7d1784e7c3451f9c1231d4fc162d", [:mix], [], "hexpm", "41195edbfb562a593726eda3b3e8b103a309b733ad25f3d642ba49696bf715dc"},
18 | "floki": {:hex, :floki, "0.32.0", "f915dc15258bc997d49be1f5ef7d3992f8834d6f5695270acad17b41f5bcc8e2", [:mix], [{:html_entities, "~> 0.5.0", [hex: :html_entities, repo: "hexpm", optional: false]}], "hexpm", "1c5a91cae1fd8931c26a4826b5e2372c284813904c8bacb468b5de39c7ececbd"},
19 | "gettext": {:hex, :gettext, "0.19.1", "564953fd21f29358e68b91634799d9d26989f8d039d7512622efb3c3b1c97892", [:mix], [], "hexpm", "10c656c0912b8299adba9b061c06947511e3f109ab0d18b44a866a4498e77222"},
20 | "html_entities": {:hex, :html_entities, "0.5.2", "9e47e70598da7de2a9ff6af8758399251db6dbb7eebe2b013f2bbd2515895c3c", [:mix], [], "hexpm", "c53ba390403485615623b9531e97696f076ed415e8d8058b1dbaa28181f4fdcc"},
21 | "jason": {:hex, :jason, "1.3.0", "fa6b82a934feb176263ad2df0dbd91bf633d4a46ebfdffea0c8ae82953714946", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "53fc1f51255390e0ec7e50f9cb41e751c260d065dcba2bf0d08dc51a4002c2ac"},
22 | "mime": {:hex, :mime, "2.0.2", "0b9e1a4c840eafb68d820b0e2158ef5c49385d17fb36855ac6e7e087d4b1dcc5", [:mix], [], "hexpm", "e6a3f76b4c277739e36c2e21a2c640778ba4c3846189d5ab19f97f126df5f9b7"},
23 | "phoenix": {:hex, :phoenix, "1.6.6", "281c8ce8dccc9f60607346b72cdfc597c3dde134dd9df28dff08282f0b751754", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 1.0", [hex: :phoenix_view, repo: "hexpm", optional: false]}, {:plug, "~> 1.10", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.2", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "807bd646e64cd9dc83db016199715faba72758e6db1de0707eef0a2da4924364"},
24 | "phoenix_ecto": {:hex, :phoenix_ecto, "4.4.0", "0672ed4e4808b3fbed494dded89958e22fb882de47a97634c0b13e7b0b5f7720", [:mix], [{:ecto, "~> 3.3", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "09864e558ed31ee00bd48fcc1d4fc58ae9678c9e81649075431e69dbabb43cc1"},
25 | "phoenix_html": {:hex, :phoenix_html, "3.2.0", "1c1219d4b6cb22ac72f12f73dc5fad6c7563104d083f711c3fcd8551a1f4ae11", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "36ec97ba56d25c0136ef1992c37957e4246b649d620958a1f9fa86165f8bc54f"},
26 | "phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.6.5", "1495bb014be12c9a9252eca04b9af54246f6b5c1e4cd1f30210cd00ec540cf8e", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.3", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.17.7", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "ef4fa50dd78364409039c99cf6f98ab5209b4c5f8796c17f4db118324f0db852"},
27 | "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.3.3", "3a53772a6118d5679bf50fc1670505a290e32a1d195df9e069d8c53ab040c054", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "766796676e5f558dbae5d1bdb066849673e956005e3730dfd5affd7a6da4abac"},
28 | "phoenix_live_view": {:hex, :phoenix_live_view, "0.17.7", "05a42377075868a678d446361effba80cefef19ab98941c01a7a4c7560b29121", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.5.9 or ~> 1.6.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.1", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "25eaf41028eb351b90d4f69671874643a09944098fefd0d01d442f40a6091b6f"},
29 | "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.0.0", "a1ae76717bb168cdeb10ec9d92d1480fec99e3080f011402c0a2d68d47395ffb", [:mix], [], "hexpm", "c52d948c4f261577b9c6fa804be91884b381a7f8f18450c5045975435350f771"},
30 | "phoenix_view": {:hex, :phoenix_view, "1.1.2", "1b82764a065fb41051637872c7bd07ed2fdb6f5c3bd89684d4dca6e10115c95a", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "7ae90ad27b09091266f6adbb61e1d2516a7c3d7062c6789d46a7554ec40f3a56"},
31 | "plug": {:hex, :plug, "1.13.3", "93b299039c21a8b82cc904d13812bce4ced45cf69153e8d35ca16ffb3e8c5d98", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "98c8003e4faf7b74a9ac41bee99e328b08f069bf932747d4a7532e97ae837a17"},
32 | "plug_cowboy": {:hex, :plug_cowboy, "2.5.2", "62894ccd601cf9597e2c23911ff12798a8a18d237e9739f58a6b04e4988899fe", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "ea6e87f774c8608d60c8d34022a7d073bd7680a0a013f049fc62bf35efea1044"},
33 | "plug_crypto": {:hex, :plug_crypto, "1.2.2", "05654514ac717ff3a1843204b424477d9e60c143406aa94daf2274fdd280794d", [:mix], [], "hexpm", "87631c7ad914a5a445f0a3809f99b079113ae4ed4b867348dd9eec288cecb6db"},
34 | "ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
35 | "swoosh": {:hex, :swoosh, "1.6.3", "598d3f07641004bedb3eede40057760ae18be1073cff72f079ca1e1fc9cd97b9", [:mix], [{:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "81ff9d7c7c4005a57465a7eb712edd71db51829aef94c8a34c30c5b9e9964adf"},
36 | "telemetry": {:hex, :telemetry, "1.0.0", "0f453a102cdf13d506b7c0ab158324c337c41f1cc7548f0bc0e130bbf0ae9452", [:rebar3], [], "hexpm", "73bc09fa59b4a0284efb4624335583c528e07ec9ae76aca96ea0673850aec57a"},
37 | "telemetry_metrics": {:hex, :telemetry_metrics, "0.6.1", "315d9163a1d4660aedc3fee73f33f1d355dcc76c5c3ab3d59e76e3edf80eef1f", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7be9e0871c41732c233be71e4be11b96e56177bf15dde64a8ac9ce72ac9834c6"},
38 | "telemetry_poller": {:hex, :telemetry_poller, "1.0.0", "db91bb424e07f2bb6e73926fcafbfcbcb295f0193e0a00e825e589a0a47e8453", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b3a24eafd66c3f42da30fc3ca7dda1e9d546c12250a2d60d7b81d264fbec4f6e"},
39 | }
40 |
--------------------------------------------------------------------------------
/priv/gettext/en/LC_MESSAGES/errors.po:
--------------------------------------------------------------------------------
1 | ## `msgid`s in this file come from POT (.pot) files.
2 | ##
3 | ## Do not add, change, or remove `msgid`s manually here as
4 | ## they're tied to the ones in the corresponding POT file
5 | ## (with the same domain).
6 | ##
7 | ## Use `mix gettext.extract --merge` or `mix gettext.merge`
8 | ## to merge POT files into PO files.
9 | msgid ""
10 | msgstr ""
11 | "Language: en\n"
12 |
13 | ## From Ecto.Changeset.cast/4
14 | msgid "can't be blank"
15 | msgstr ""
16 |
17 | ## From Ecto.Changeset.unique_constraint/3
18 | msgid "has already been taken"
19 | msgstr ""
20 |
21 | ## From Ecto.Changeset.put_change/3
22 | msgid "is invalid"
23 | msgstr ""
24 |
25 | ## From Ecto.Changeset.validate_acceptance/3
26 | msgid "must be accepted"
27 | msgstr ""
28 |
29 | ## From Ecto.Changeset.validate_format/3
30 | msgid "has invalid format"
31 | msgstr ""
32 |
33 | ## From Ecto.Changeset.validate_subset/3
34 | msgid "has an invalid entry"
35 | msgstr ""
36 |
37 | ## From Ecto.Changeset.validate_exclusion/3
38 | msgid "is reserved"
39 | msgstr ""
40 |
41 | ## From Ecto.Changeset.validate_confirmation/3
42 | msgid "does not match confirmation"
43 | msgstr ""
44 |
45 | ## From Ecto.Changeset.no_assoc_constraint/3
46 | msgid "is still associated with this entry"
47 | msgstr ""
48 |
49 | msgid "are still associated with this entry"
50 | msgstr ""
51 |
52 | ## From Ecto.Changeset.validate_length/3
53 | msgid "should have %{count} item(s)"
54 | msgid_plural "should have %{count} item(s)"
55 | msgstr[0] ""
56 | msgstr[1] ""
57 |
58 | msgid "should be %{count} character(s)"
59 | msgid_plural "should be %{count} character(s)"
60 | msgstr[0] ""
61 | msgstr[1] ""
62 |
63 | msgid "should be %{count} byte(s)"
64 | msgid_plural "should be %{count} byte(s)"
65 | msgstr[0] ""
66 | msgstr[1] ""
67 |
68 | msgid "should have at least %{count} item(s)"
69 | msgid_plural "should have at least %{count} item(s)"
70 | msgstr[0] ""
71 | msgstr[1] ""
72 |
73 | msgid "should be at least %{count} character(s)"
74 | msgid_plural "should be at least %{count} character(s)"
75 | msgstr[0] ""
76 | msgstr[1] ""
77 |
78 | msgid "should be at least %{count} byte(s)"
79 | msgid_plural "should be at least %{count} byte(s)"
80 | msgstr[0] ""
81 | msgstr[1] ""
82 |
83 | msgid "should have at most %{count} item(s)"
84 | msgid_plural "should have at most %{count} item(s)"
85 | msgstr[0] ""
86 | msgstr[1] ""
87 |
88 | msgid "should be at most %{count} character(s)"
89 | msgid_plural "should be at most %{count} character(s)"
90 | msgstr[0] ""
91 | msgstr[1] ""
92 |
93 | msgid "should be at most %{count} byte(s)"
94 | msgid_plural "should be at most %{count} byte(s)"
95 | msgstr[0] ""
96 | msgstr[1] ""
97 |
98 | ## From Ecto.Changeset.validate_number/3
99 | msgid "must be less than %{number}"
100 | msgstr ""
101 |
102 | msgid "must be greater than %{number}"
103 | msgstr ""
104 |
105 | msgid "must be less than or equal to %{number}"
106 | msgstr ""
107 |
108 | msgid "must be greater than or equal to %{number}"
109 | msgstr ""
110 |
111 | msgid "must be equal to %{number}"
112 | msgstr ""
113 |
--------------------------------------------------------------------------------
/priv/gettext/errors.pot:
--------------------------------------------------------------------------------
1 | ## This is a PO Template file.
2 | ##
3 | ## `msgid`s here are often extracted from source code.
4 | ## Add new translations manually only if they're dynamic
5 | ## translations that can't be statically extracted.
6 | ##
7 | ## Run `mix gettext.extract` to bring this file up to
8 | ## date. Leave `msgstr`s empty as changing them here has no
9 | ## effect: edit them in PO (`.po`) files instead.
10 |
11 | ## From Ecto.Changeset.cast/4
12 | msgid "can't be blank"
13 | msgstr ""
14 |
15 | ## From Ecto.Changeset.unique_constraint/3
16 | msgid "has already been taken"
17 | msgstr ""
18 |
19 | ## From Ecto.Changeset.put_change/3
20 | msgid "is invalid"
21 | msgstr ""
22 |
23 | ## From Ecto.Changeset.validate_acceptance/3
24 | msgid "must be accepted"
25 | msgstr ""
26 |
27 | ## From Ecto.Changeset.validate_format/3
28 | msgid "has invalid format"
29 | msgstr ""
30 |
31 | ## From Ecto.Changeset.validate_subset/3
32 | msgid "has an invalid entry"
33 | msgstr ""
34 |
35 | ## From Ecto.Changeset.validate_exclusion/3
36 | msgid "is reserved"
37 | msgstr ""
38 |
39 | ## From Ecto.Changeset.validate_confirmation/3
40 | msgid "does not match confirmation"
41 | msgstr ""
42 |
43 | ## From Ecto.Changeset.no_assoc_constraint/3
44 | msgid "is still associated with this entry"
45 | msgstr ""
46 |
47 | msgid "are still associated with this entry"
48 | msgstr ""
49 |
50 | ## From Ecto.Changeset.validate_length/3
51 | msgid "should be %{count} character(s)"
52 | msgid_plural "should be %{count} character(s)"
53 | msgstr[0] ""
54 | msgstr[1] ""
55 |
56 | msgid "should have %{count} item(s)"
57 | msgid_plural "should have %{count} item(s)"
58 | msgstr[0] ""
59 | msgstr[1] ""
60 |
61 | msgid "should be at least %{count} character(s)"
62 | msgid_plural "should be at least %{count} character(s)"
63 | msgstr[0] ""
64 | msgstr[1] ""
65 |
66 | msgid "should have at least %{count} item(s)"
67 | msgid_plural "should have at least %{count} item(s)"
68 | msgstr[0] ""
69 | msgstr[1] ""
70 |
71 | msgid "should be at most %{count} character(s)"
72 | msgid_plural "should be at most %{count} character(s)"
73 | msgstr[0] ""
74 | msgstr[1] ""
75 |
76 | msgid "should have at most %{count} item(s)"
77 | msgid_plural "should have at most %{count} item(s)"
78 | msgstr[0] ""
79 | msgstr[1] ""
80 |
81 | ## From Ecto.Changeset.validate_number/3
82 | msgid "must be less than %{number}"
83 | msgstr ""
84 |
85 | msgid "must be greater than %{number}"
86 | msgstr ""
87 |
88 | msgid "must be less than or equal to %{number}"
89 | msgstr ""
90 |
91 | msgid "must be greater than or equal to %{number}"
92 | msgstr ""
93 |
94 | msgid "must be equal to %{number}"
95 | msgstr ""
96 |
--------------------------------------------------------------------------------
/priv/repo/migrations/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:ecto_sql],
3 | inputs: ["*.exs"]
4 | ]
5 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20220221061920_create_users_auth_tables.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScale.Repo.Migrations.CreateUsersAuthTables do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:users, primary_key: false) do
6 | add :id, :binary_id, primary_key: true
7 | add :email, :string, null: false, collate: :nocase
8 | add :hashed_password, :string, null: false
9 | add :confirmed_at, :naive_datetime
10 | timestamps()
11 | end
12 |
13 | create unique_index(:users, [:email])
14 |
15 | create table(:users_tokens, primary_key: false) do
16 | add :id, :binary_id, primary_key: true
17 | add :user_id, references(:users, type: :binary_id, on_delete: :delete_all), null: false
18 | add :token, :binary, null: false, size: 32
19 | add :context, :string, null: false
20 | add :sent_to, :string
21 | timestamps(updated_at: false)
22 | end
23 |
24 | create index(:users_tokens, [:user_id])
25 | create unique_index(:users_tokens, [:context, :token])
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/priv/repo/seeds.exs:
--------------------------------------------------------------------------------
1 | # Script for populating the database. You can run it as:
2 | #
3 | # mix run priv/repo/seeds.exs
4 | #
5 | # Inside the script, you can read and write to any of your
6 | # repositories directly:
7 | #
8 | # SqliteScale.Repo.insert!(%SqliteScale.SomeSchema{})
9 | #
10 | # We recommend using the bang functions (`insert!`, `update!`
11 | # and so on) as they will fail if something goes wrong.
12 |
--------------------------------------------------------------------------------
/priv/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/akoutmos/sqlite_scale/b136972322c2e7fb1db0af2cad9e16d7ef22a975/priv/static/favicon.ico
--------------------------------------------------------------------------------
/priv/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/akoutmos/sqlite_scale/b136972322c2e7fb1db0af2cad9e16d7ef22a975/priv/static/images/phoenix.png
--------------------------------------------------------------------------------
/priv/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See https://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-agent: *
5 | # Disallow: /
6 |
--------------------------------------------------------------------------------
/priv/user_repo/migrations/20220221192607_add_todo_list_table.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScale.UserRepo.Migrations.AddTodoListTable do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:todo_items, primary_key: false) do
6 | add(:id, :binary_id, primary_key: true)
7 | add(:item, :string, null: false)
8 |
9 | timestamps()
10 | end
11 | end
12 | end
13 |
--------------------------------------------------------------------------------
/test/sqlite_scale/accounts_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScale.AccountsTest do
2 | use SqliteScale.DataCase
3 |
4 | alias SqliteScale.Accounts
5 |
6 | import SqliteScale.AccountsFixtures
7 | alias SqliteScale.Accounts.{User, UserToken}
8 |
9 | describe "get_user_by_email/1" do
10 | test "does not return the user if the email does not exist" do
11 | refute Accounts.get_user_by_email("unknown@example.com")
12 | end
13 |
14 | test "returns the user if the email exists" do
15 | %{id: id} = user = user_fixture()
16 | assert %User{id: ^id} = Accounts.get_user_by_email(user.email)
17 | end
18 | end
19 |
20 | describe "get_user_by_email_and_password/2" do
21 | test "does not return the user if the email does not exist" do
22 | refute Accounts.get_user_by_email_and_password("unknown@example.com", "hello world!")
23 | end
24 |
25 | test "does not return the user if the password is not valid" do
26 | user = user_fixture()
27 | refute Accounts.get_user_by_email_and_password(user.email, "invalid")
28 | end
29 |
30 | test "returns the user if the email and password are valid" do
31 | %{id: id} = user = user_fixture()
32 |
33 | assert %User{id: ^id} =
34 | Accounts.get_user_by_email_and_password(user.email, valid_user_password())
35 | end
36 | end
37 |
38 | describe "get_user!/1" do
39 | test "raises if id is invalid" do
40 | assert_raise Ecto.NoResultsError, fn ->
41 | Accounts.get_user!("11111111-1111-1111-1111-111111111111")
42 | end
43 | end
44 |
45 | test "returns the user with the given id" do
46 | %{id: id} = user = user_fixture()
47 | assert %User{id: ^id} = Accounts.get_user!(user.id)
48 | end
49 | end
50 |
51 | describe "register_user/1" do
52 | test "requires email and password to be set" do
53 | {:error, changeset} = Accounts.register_user(%{})
54 |
55 | assert %{
56 | password: ["can't be blank"],
57 | email: ["can't be blank"]
58 | } = errors_on(changeset)
59 | end
60 |
61 | test "validates email and password when given" do
62 | {:error, changeset} = Accounts.register_user(%{email: "not valid", password: "not valid"})
63 |
64 | assert %{
65 | email: ["must have the @ sign and no spaces"],
66 | password: ["should be at least 12 character(s)"]
67 | } = errors_on(changeset)
68 | end
69 |
70 | test "validates maximum values for email and password for security" do
71 | too_long = String.duplicate("db", 100)
72 | {:error, changeset} = Accounts.register_user(%{email: too_long, password: too_long})
73 | assert "should be at most 160 character(s)" in errors_on(changeset).email
74 | assert "should be at most 72 character(s)" in errors_on(changeset).password
75 | end
76 |
77 | test "validates email uniqueness" do
78 | %{email: email} = user_fixture()
79 | {:error, changeset} = Accounts.register_user(%{email: email})
80 | assert "has already been taken" in errors_on(changeset).email
81 |
82 | # Now try with the upper cased email too, to check that email case is ignored.
83 | {:error, changeset} = Accounts.register_user(%{email: String.upcase(email)})
84 | assert "has already been taken" in errors_on(changeset).email
85 | end
86 |
87 | test "registers users with a hashed password" do
88 | email = unique_user_email()
89 | {:ok, user} = Accounts.register_user(valid_user_attributes(email: email))
90 | assert user.email == email
91 | assert is_binary(user.hashed_password)
92 | assert is_nil(user.confirmed_at)
93 | assert is_nil(user.password)
94 | end
95 | end
96 |
97 | describe "change_user_registration/2" do
98 | test "returns a changeset" do
99 | assert %Ecto.Changeset{} = changeset = Accounts.change_user_registration(%User{})
100 | assert changeset.required == [:password, :email]
101 | end
102 |
103 | test "allows fields to be set" do
104 | email = unique_user_email()
105 | password = valid_user_password()
106 |
107 | changeset =
108 | Accounts.change_user_registration(
109 | %User{},
110 | valid_user_attributes(email: email, password: password)
111 | )
112 |
113 | assert changeset.valid?
114 | assert get_change(changeset, :email) == email
115 | assert get_change(changeset, :password) == password
116 | assert is_nil(get_change(changeset, :hashed_password))
117 | end
118 | end
119 |
120 | describe "change_user_email/2" do
121 | test "returns a user changeset" do
122 | assert %Ecto.Changeset{} = changeset = Accounts.change_user_email(%User{})
123 | assert changeset.required == [:email]
124 | end
125 | end
126 |
127 | describe "apply_user_email/3" do
128 | setup do
129 | %{user: user_fixture()}
130 | end
131 |
132 | test "requires email to change", %{user: user} do
133 | {:error, changeset} = Accounts.apply_user_email(user, valid_user_password(), %{})
134 | assert %{email: ["did not change"]} = errors_on(changeset)
135 | end
136 |
137 | test "validates email", %{user: user} do
138 | {:error, changeset} =
139 | Accounts.apply_user_email(user, valid_user_password(), %{email: "not valid"})
140 |
141 | assert %{email: ["must have the @ sign and no spaces"]} = errors_on(changeset)
142 | end
143 |
144 | test "validates maximum value for email for security", %{user: user} do
145 | too_long = String.duplicate("db", 100)
146 |
147 | {:error, changeset} =
148 | Accounts.apply_user_email(user, valid_user_password(), %{email: too_long})
149 |
150 | assert "should be at most 160 character(s)" in errors_on(changeset).email
151 | end
152 |
153 | test "validates email uniqueness", %{user: user} do
154 | %{email: email} = user_fixture()
155 |
156 | {:error, changeset} =
157 | Accounts.apply_user_email(user, valid_user_password(), %{email: email})
158 |
159 | assert "has already been taken" in errors_on(changeset).email
160 | end
161 |
162 | test "validates current password", %{user: user} do
163 | {:error, changeset} =
164 | Accounts.apply_user_email(user, "invalid", %{email: unique_user_email()})
165 |
166 | assert %{current_password: ["is not valid"]} = errors_on(changeset)
167 | end
168 |
169 | test "applies the email without persisting it", %{user: user} do
170 | email = unique_user_email()
171 | {:ok, user} = Accounts.apply_user_email(user, valid_user_password(), %{email: email})
172 | assert user.email == email
173 | assert Accounts.get_user!(user.id).email != email
174 | end
175 | end
176 |
177 | describe "deliver_update_email_instructions/3" do
178 | setup do
179 | %{user: user_fixture()}
180 | end
181 |
182 | test "sends token through notification", %{user: user} do
183 | token =
184 | extract_user_token(fn url ->
185 | Accounts.deliver_update_email_instructions(user, "current@example.com", url)
186 | end)
187 |
188 | {:ok, token} = Base.url_decode64(token, padding: false)
189 | assert user_token = Repo.get_by(UserToken, token: :crypto.hash(:sha256, token))
190 | assert user_token.user_id == user.id
191 | assert user_token.sent_to == user.email
192 | assert user_token.context == "change:current@example.com"
193 | end
194 | end
195 |
196 | describe "update_user_email/2" do
197 | setup do
198 | user = user_fixture()
199 | email = unique_user_email()
200 |
201 | token =
202 | extract_user_token(fn url ->
203 | Accounts.deliver_update_email_instructions(%{user | email: email}, user.email, url)
204 | end)
205 |
206 | %{user: user, token: token, email: email}
207 | end
208 |
209 | test "updates the email with a valid token", %{user: user, token: token, email: email} do
210 | assert Accounts.update_user_email(user, token) == :ok
211 | changed_user = Repo.get!(User, user.id)
212 | assert changed_user.email != user.email
213 | assert changed_user.email == email
214 | assert changed_user.confirmed_at
215 | assert changed_user.confirmed_at != user.confirmed_at
216 | refute Repo.get_by(UserToken, user_id: user.id)
217 | end
218 |
219 | test "does not update email with invalid token", %{user: user} do
220 | assert Accounts.update_user_email(user, "oops") == :error
221 | assert Repo.get!(User, user.id).email == user.email
222 | assert Repo.get_by(UserToken, user_id: user.id)
223 | end
224 |
225 | test "does not update email if user email changed", %{user: user, token: token} do
226 | assert Accounts.update_user_email(%{user | email: "current@example.com"}, token) == :error
227 | assert Repo.get!(User, user.id).email == user.email
228 | assert Repo.get_by(UserToken, user_id: user.id)
229 | end
230 |
231 | test "does not update email if token expired", %{user: user, token: token} do
232 | {1, nil} = Repo.update_all(UserToken, set: [inserted_at: ~N[2020-01-01 00:00:00]])
233 | assert Accounts.update_user_email(user, token) == :error
234 | assert Repo.get!(User, user.id).email == user.email
235 | assert Repo.get_by(UserToken, user_id: user.id)
236 | end
237 | end
238 |
239 | describe "change_user_password/2" do
240 | test "returns a user changeset" do
241 | assert %Ecto.Changeset{} = changeset = Accounts.change_user_password(%User{})
242 | assert changeset.required == [:password]
243 | end
244 |
245 | test "allows fields to be set" do
246 | changeset =
247 | Accounts.change_user_password(%User{}, %{
248 | "password" => "new valid password"
249 | })
250 |
251 | assert changeset.valid?
252 | assert get_change(changeset, :password) == "new valid password"
253 | assert is_nil(get_change(changeset, :hashed_password))
254 | end
255 | end
256 |
257 | describe "update_user_password/3" do
258 | setup do
259 | %{user: user_fixture()}
260 | end
261 |
262 | test "validates password", %{user: user} do
263 | {:error, changeset} =
264 | Accounts.update_user_password(user, valid_user_password(), %{
265 | password: "not valid",
266 | password_confirmation: "another"
267 | })
268 |
269 | assert %{
270 | password: ["should be at least 12 character(s)"],
271 | password_confirmation: ["does not match password"]
272 | } = errors_on(changeset)
273 | end
274 |
275 | test "validates maximum values for password for security", %{user: user} do
276 | too_long = String.duplicate("db", 100)
277 |
278 | {:error, changeset} =
279 | Accounts.update_user_password(user, valid_user_password(), %{password: too_long})
280 |
281 | assert "should be at most 72 character(s)" in errors_on(changeset).password
282 | end
283 |
284 | test "validates current password", %{user: user} do
285 | {:error, changeset} =
286 | Accounts.update_user_password(user, "invalid", %{password: valid_user_password()})
287 |
288 | assert %{current_password: ["is not valid"]} = errors_on(changeset)
289 | end
290 |
291 | test "updates the password", %{user: user} do
292 | {:ok, user} =
293 | Accounts.update_user_password(user, valid_user_password(), %{
294 | password: "new valid password"
295 | })
296 |
297 | assert is_nil(user.password)
298 | assert Accounts.get_user_by_email_and_password(user.email, "new valid password")
299 | end
300 |
301 | test "deletes all tokens for the given user", %{user: user} do
302 | _ = Accounts.generate_user_session_token(user)
303 |
304 | {:ok, _} =
305 | Accounts.update_user_password(user, valid_user_password(), %{
306 | password: "new valid password"
307 | })
308 |
309 | refute Repo.get_by(UserToken, user_id: user.id)
310 | end
311 | end
312 |
313 | describe "generate_user_session_token/1" do
314 | setup do
315 | %{user: user_fixture()}
316 | end
317 |
318 | test "generates a token", %{user: user} do
319 | token = Accounts.generate_user_session_token(user)
320 | assert user_token = Repo.get_by(UserToken, token: token)
321 | assert user_token.context == "session"
322 |
323 | # Creating the same token for another user should fail
324 | assert_raise Ecto.ConstraintError, fn ->
325 | Repo.insert!(%UserToken{
326 | token: user_token.token,
327 | user_id: user_fixture().id,
328 | context: "session"
329 | })
330 | end
331 | end
332 | end
333 |
334 | describe "get_user_by_session_token/1" do
335 | setup do
336 | user = user_fixture()
337 | token = Accounts.generate_user_session_token(user)
338 | %{user: user, token: token}
339 | end
340 |
341 | test "returns user by token", %{user: user, token: token} do
342 | assert session_user = Accounts.get_user_by_session_token(token)
343 | assert session_user.id == user.id
344 | end
345 |
346 | test "does not return user for invalid token" do
347 | refute Accounts.get_user_by_session_token("oops")
348 | end
349 |
350 | test "does not return user for expired token", %{token: token} do
351 | {1, nil} = Repo.update_all(UserToken, set: [inserted_at: ~N[2020-01-01 00:00:00]])
352 | refute Accounts.get_user_by_session_token(token)
353 | end
354 | end
355 |
356 | describe "delete_session_token/1" do
357 | test "deletes the token" do
358 | user = user_fixture()
359 | token = Accounts.generate_user_session_token(user)
360 | assert Accounts.delete_session_token(token) == :ok
361 | refute Accounts.get_user_by_session_token(token)
362 | end
363 | end
364 |
365 | describe "deliver_user_confirmation_instructions/2" do
366 | setup do
367 | %{user: user_fixture()}
368 | end
369 |
370 | test "sends token through notification", %{user: user} do
371 | token =
372 | extract_user_token(fn url ->
373 | Accounts.deliver_user_confirmation_instructions(user, url)
374 | end)
375 |
376 | {:ok, token} = Base.url_decode64(token, padding: false)
377 | assert user_token = Repo.get_by(UserToken, token: :crypto.hash(:sha256, token))
378 | assert user_token.user_id == user.id
379 | assert user_token.sent_to == user.email
380 | assert user_token.context == "confirm"
381 | end
382 | end
383 |
384 | describe "confirm_user/1" do
385 | setup do
386 | user = user_fixture()
387 |
388 | token =
389 | extract_user_token(fn url ->
390 | Accounts.deliver_user_confirmation_instructions(user, url)
391 | end)
392 |
393 | %{user: user, token: token}
394 | end
395 |
396 | test "confirms the email with a valid token", %{user: user, token: token} do
397 | assert {:ok, confirmed_user} = Accounts.confirm_user(token)
398 | assert confirmed_user.confirmed_at
399 | assert confirmed_user.confirmed_at != user.confirmed_at
400 | assert Repo.get!(User, user.id).confirmed_at
401 | refute Repo.get_by(UserToken, user_id: user.id)
402 | end
403 |
404 | test "does not confirm with invalid token", %{user: user} do
405 | assert Accounts.confirm_user("oops") == :error
406 | refute Repo.get!(User, user.id).confirmed_at
407 | assert Repo.get_by(UserToken, user_id: user.id)
408 | end
409 |
410 | test "does not confirm email if token expired", %{user: user, token: token} do
411 | {1, nil} = Repo.update_all(UserToken, set: [inserted_at: ~N[2020-01-01 00:00:00]])
412 | assert Accounts.confirm_user(token) == :error
413 | refute Repo.get!(User, user.id).confirmed_at
414 | assert Repo.get_by(UserToken, user_id: user.id)
415 | end
416 | end
417 |
418 | describe "deliver_user_reset_password_instructions/2" do
419 | setup do
420 | %{user: user_fixture()}
421 | end
422 |
423 | test "sends token through notification", %{user: user} do
424 | token =
425 | extract_user_token(fn url ->
426 | Accounts.deliver_user_reset_password_instructions(user, url)
427 | end)
428 |
429 | {:ok, token} = Base.url_decode64(token, padding: false)
430 | assert user_token = Repo.get_by(UserToken, token: :crypto.hash(:sha256, token))
431 | assert user_token.user_id == user.id
432 | assert user_token.sent_to == user.email
433 | assert user_token.context == "reset_password"
434 | end
435 | end
436 |
437 | describe "get_user_by_reset_password_token/1" do
438 | setup do
439 | user = user_fixture()
440 |
441 | token =
442 | extract_user_token(fn url ->
443 | Accounts.deliver_user_reset_password_instructions(user, url)
444 | end)
445 |
446 | %{user: user, token: token}
447 | end
448 |
449 | test "returns the user with valid token", %{user: %{id: id}, token: token} do
450 | assert %User{id: ^id} = Accounts.get_user_by_reset_password_token(token)
451 | assert Repo.get_by(UserToken, user_id: id)
452 | end
453 |
454 | test "does not return the user with invalid token", %{user: user} do
455 | refute Accounts.get_user_by_reset_password_token("oops")
456 | assert Repo.get_by(UserToken, user_id: user.id)
457 | end
458 |
459 | test "does not return the user if token expired", %{user: user, token: token} do
460 | {1, nil} = Repo.update_all(UserToken, set: [inserted_at: ~N[2020-01-01 00:00:00]])
461 | refute Accounts.get_user_by_reset_password_token(token)
462 | assert Repo.get_by(UserToken, user_id: user.id)
463 | end
464 | end
465 |
466 | describe "reset_user_password/2" do
467 | setup do
468 | %{user: user_fixture()}
469 | end
470 |
471 | test "validates password", %{user: user} do
472 | {:error, changeset} =
473 | Accounts.reset_user_password(user, %{
474 | password: "not valid",
475 | password_confirmation: "another"
476 | })
477 |
478 | assert %{
479 | password: ["should be at least 12 character(s)"],
480 | password_confirmation: ["does not match password"]
481 | } = errors_on(changeset)
482 | end
483 |
484 | test "validates maximum values for password for security", %{user: user} do
485 | too_long = String.duplicate("db", 100)
486 | {:error, changeset} = Accounts.reset_user_password(user, %{password: too_long})
487 | assert "should be at most 72 character(s)" in errors_on(changeset).password
488 | end
489 |
490 | test "updates the password", %{user: user} do
491 | {:ok, updated_user} = Accounts.reset_user_password(user, %{password: "new valid password"})
492 | assert is_nil(updated_user.password)
493 | assert Accounts.get_user_by_email_and_password(user.email, "new valid password")
494 | end
495 |
496 | test "deletes all tokens for the given user", %{user: user} do
497 | _ = Accounts.generate_user_session_token(user)
498 | {:ok, _} = Accounts.reset_user_password(user, %{password: "new valid password"})
499 | refute Repo.get_by(UserToken, user_id: user.id)
500 | end
501 | end
502 |
503 | describe "inspect/2" do
504 | test "does not include password" do
505 | refute inspect(%User{password: "123456"}) =~ "password: \"123456\""
506 | end
507 | end
508 | end
509 |
--------------------------------------------------------------------------------
/test/sqlite_scale/todo_items_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScale.TodoItemsTest do
2 | use SqliteScale.DataCase
3 |
4 | alias SqliteScale.TodoItems
5 |
6 | describe "todo_items" do
7 | alias SqliteScale.TodoItems.TodoItem
8 |
9 | import SqliteScale.TodoItemsFixtures
10 |
11 | @invalid_attrs %{item: nil}
12 |
13 | test "list_todo_items/0 returns all todo_items" do
14 | todo_item = todo_item_fixture()
15 | assert TodoItems.list_todo_items() == [todo_item]
16 | end
17 |
18 | test "get_todo_item!/1 returns the todo_item with given id" do
19 | todo_item = todo_item_fixture()
20 | assert TodoItems.get_todo_item!(todo_item.id) == todo_item
21 | end
22 |
23 | test "create_todo_item/1 with valid data creates a todo_item" do
24 | valid_attrs = %{item: "some item"}
25 |
26 | assert {:ok, %TodoItem{} = todo_item} = TodoItems.create_todo_item(valid_attrs)
27 | assert todo_item.item == "some item"
28 | end
29 |
30 | test "create_todo_item/1 with invalid data returns error changeset" do
31 | assert {:error, %Ecto.Changeset{}} = TodoItems.create_todo_item(@invalid_attrs)
32 | end
33 |
34 | test "update_todo_item/2 with valid data updates the todo_item" do
35 | todo_item = todo_item_fixture()
36 | update_attrs = %{item: "some updated item"}
37 |
38 | assert {:ok, %TodoItem{} = todo_item} = TodoItems.update_todo_item(todo_item, update_attrs)
39 | assert todo_item.item == "some updated item"
40 | end
41 |
42 | test "update_todo_item/2 with invalid data returns error changeset" do
43 | todo_item = todo_item_fixture()
44 | assert {:error, %Ecto.Changeset{}} = TodoItems.update_todo_item(todo_item, @invalid_attrs)
45 | assert todo_item == TodoItems.get_todo_item!(todo_item.id)
46 | end
47 |
48 | test "delete_todo_item/1 deletes the todo_item" do
49 | todo_item = todo_item_fixture()
50 | assert {:ok, %TodoItem{}} = TodoItems.delete_todo_item(todo_item)
51 | assert_raise Ecto.NoResultsError, fn -> TodoItems.get_todo_item!(todo_item.id) end
52 | end
53 |
54 | test "change_todo_item/1 returns a todo_item changeset" do
55 | todo_item = todo_item_fixture()
56 | assert %Ecto.Changeset{} = TodoItems.change_todo_item(todo_item)
57 | end
58 | end
59 | end
60 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/controllers/page_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.PageControllerTest do
2 | use SqliteScaleWeb.ConnCase
3 |
4 | test "GET /", %{conn: conn} do
5 | conn = get(conn, "/")
6 | assert html_response(conn, 200) =~ "Welcome to Phoenix!"
7 | end
8 | end
9 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/controllers/todo_item_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.TodoItemControllerTest do
2 | use SqliteScaleWeb.ConnCase
3 |
4 | import SqliteScale.TodoItemsFixtures
5 |
6 | @create_attrs %{item: "some item"}
7 | @update_attrs %{item: "some updated item"}
8 | @invalid_attrs %{item: nil}
9 |
10 | describe "index" do
11 | test "lists all todo_items", %{conn: conn} do
12 | conn = get(conn, Routes.todo_item_path(conn, :index))
13 | assert html_response(conn, 200) =~ "Listing Todo items"
14 | end
15 | end
16 |
17 | describe "new todo_item" do
18 | test "renders form", %{conn: conn} do
19 | conn = get(conn, Routes.todo_item_path(conn, :new))
20 | assert html_response(conn, 200) =~ "New Todo item"
21 | end
22 | end
23 |
24 | describe "create todo_item" do
25 | test "redirects to show when data is valid", %{conn: conn} do
26 | conn = post(conn, Routes.todo_item_path(conn, :create), todo_item: @create_attrs)
27 |
28 | assert %{id: id} = redirected_params(conn)
29 | assert redirected_to(conn) == Routes.todo_item_path(conn, :show, id)
30 |
31 | conn = get(conn, Routes.todo_item_path(conn, :show, id))
32 | assert html_response(conn, 200) =~ "Show Todo item"
33 | end
34 |
35 | test "renders errors when data is invalid", %{conn: conn} do
36 | conn = post(conn, Routes.todo_item_path(conn, :create), todo_item: @invalid_attrs)
37 | assert html_response(conn, 200) =~ "New Todo item"
38 | end
39 | end
40 |
41 | describe "edit todo_item" do
42 | setup [:create_todo_item]
43 |
44 | test "renders form for editing chosen todo_item", %{conn: conn, todo_item: todo_item} do
45 | conn = get(conn, Routes.todo_item_path(conn, :edit, todo_item))
46 | assert html_response(conn, 200) =~ "Edit Todo item"
47 | end
48 | end
49 |
50 | describe "update todo_item" do
51 | setup [:create_todo_item]
52 |
53 | test "redirects when data is valid", %{conn: conn, todo_item: todo_item} do
54 | conn = put(conn, Routes.todo_item_path(conn, :update, todo_item), todo_item: @update_attrs)
55 | assert redirected_to(conn) == Routes.todo_item_path(conn, :show, todo_item)
56 |
57 | conn = get(conn, Routes.todo_item_path(conn, :show, todo_item))
58 | assert html_response(conn, 200) =~ "some updated item"
59 | end
60 |
61 | test "renders errors when data is invalid", %{conn: conn, todo_item: todo_item} do
62 | conn = put(conn, Routes.todo_item_path(conn, :update, todo_item), todo_item: @invalid_attrs)
63 | assert html_response(conn, 200) =~ "Edit Todo item"
64 | end
65 | end
66 |
67 | describe "delete todo_item" do
68 | setup [:create_todo_item]
69 |
70 | test "deletes chosen todo_item", %{conn: conn, todo_item: todo_item} do
71 | conn = delete(conn, Routes.todo_item_path(conn, :delete, todo_item))
72 | assert redirected_to(conn) == Routes.todo_item_path(conn, :index)
73 |
74 | assert_error_sent 404, fn ->
75 | get(conn, Routes.todo_item_path(conn, :show, todo_item))
76 | end
77 | end
78 | end
79 |
80 | defp create_todo_item(_) do
81 | todo_item = todo_item_fixture()
82 | %{todo_item: todo_item}
83 | end
84 | end
85 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/controllers/user_auth_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserAuthTest do
2 | use SqliteScaleWeb.ConnCase
3 |
4 | alias SqliteScale.Accounts
5 | alias SqliteScaleWeb.UserAuth
6 | import SqliteScale.AccountsFixtures
7 |
8 | @remember_me_cookie "_sqlite_scale_web_user_remember_me"
9 |
10 | setup %{conn: conn} do
11 | conn =
12 | conn
13 | |> Map.replace!(:secret_key_base, SqliteScaleWeb.Endpoint.config(:secret_key_base))
14 | |> init_test_session(%{})
15 |
16 | %{user: user_fixture(), conn: conn}
17 | end
18 |
19 | describe "log_in_user/3" do
20 | test "stores the user token in the session", %{conn: conn, user: user} do
21 | conn = UserAuth.log_in_user(conn, user)
22 | assert token = get_session(conn, :user_token)
23 | assert get_session(conn, :live_socket_id) == "users_sessions:#{Base.url_encode64(token)}"
24 | assert redirected_to(conn) == "/"
25 | assert Accounts.get_user_by_session_token(token)
26 | end
27 |
28 | test "clears everything previously stored in the session", %{conn: conn, user: user} do
29 | conn = conn |> put_session(:to_be_removed, "value") |> UserAuth.log_in_user(user)
30 | refute get_session(conn, :to_be_removed)
31 | end
32 |
33 | test "redirects to the configured path", %{conn: conn, user: user} do
34 | conn = conn |> put_session(:user_return_to, "/hello") |> UserAuth.log_in_user(user)
35 | assert redirected_to(conn) == "/hello"
36 | end
37 |
38 | test "writes a cookie if remember_me is configured", %{conn: conn, user: user} do
39 | conn = conn |> fetch_cookies() |> UserAuth.log_in_user(user, %{"remember_me" => "true"})
40 | assert get_session(conn, :user_token) == conn.cookies[@remember_me_cookie]
41 |
42 | assert %{value: signed_token, max_age: max_age} = conn.resp_cookies[@remember_me_cookie]
43 | assert signed_token != get_session(conn, :user_token)
44 | assert max_age == 5_184_000
45 | end
46 | end
47 |
48 | describe "logout_user/1" do
49 | test "erases session and cookies", %{conn: conn, user: user} do
50 | user_token = Accounts.generate_user_session_token(user)
51 |
52 | conn =
53 | conn
54 | |> put_session(:user_token, user_token)
55 | |> put_req_cookie(@remember_me_cookie, user_token)
56 | |> fetch_cookies()
57 | |> UserAuth.log_out_user()
58 |
59 | refute get_session(conn, :user_token)
60 | refute conn.cookies[@remember_me_cookie]
61 | assert %{max_age: 0} = conn.resp_cookies[@remember_me_cookie]
62 | assert redirected_to(conn) == "/"
63 | refute Accounts.get_user_by_session_token(user_token)
64 | end
65 |
66 | test "broadcasts to the given live_socket_id", %{conn: conn} do
67 | live_socket_id = "users_sessions:abcdef-token"
68 | SqliteScaleWeb.Endpoint.subscribe(live_socket_id)
69 |
70 | conn
71 | |> put_session(:live_socket_id, live_socket_id)
72 | |> UserAuth.log_out_user()
73 |
74 | assert_receive %Phoenix.Socket.Broadcast{event: "disconnect", topic: ^live_socket_id}
75 | end
76 |
77 | test "works even if user is already logged out", %{conn: conn} do
78 | conn = conn |> fetch_cookies() |> UserAuth.log_out_user()
79 | refute get_session(conn, :user_token)
80 | assert %{max_age: 0} = conn.resp_cookies[@remember_me_cookie]
81 | assert redirected_to(conn) == "/"
82 | end
83 | end
84 |
85 | describe "fetch_current_user/2" do
86 | test "authenticates user from session", %{conn: conn, user: user} do
87 | user_token = Accounts.generate_user_session_token(user)
88 | conn = conn |> put_session(:user_token, user_token) |> UserAuth.fetch_current_user([])
89 | assert conn.assigns.current_user.id == user.id
90 | end
91 |
92 | test "authenticates user from cookies", %{conn: conn, user: user} do
93 | logged_in_conn =
94 | conn |> fetch_cookies() |> UserAuth.log_in_user(user, %{"remember_me" => "true"})
95 |
96 | user_token = logged_in_conn.cookies[@remember_me_cookie]
97 | %{value: signed_token} = logged_in_conn.resp_cookies[@remember_me_cookie]
98 |
99 | conn =
100 | conn
101 | |> put_req_cookie(@remember_me_cookie, signed_token)
102 | |> UserAuth.fetch_current_user([])
103 |
104 | assert get_session(conn, :user_token) == user_token
105 | assert conn.assigns.current_user.id == user.id
106 | end
107 |
108 | test "does not authenticate if data is missing", %{conn: conn, user: user} do
109 | _ = Accounts.generate_user_session_token(user)
110 | conn = UserAuth.fetch_current_user(conn, [])
111 | refute get_session(conn, :user_token)
112 | refute conn.assigns.current_user
113 | end
114 | end
115 |
116 | describe "redirect_if_user_is_authenticated/2" do
117 | test "redirects if user is authenticated", %{conn: conn, user: user} do
118 | conn = conn |> assign(:current_user, user) |> UserAuth.redirect_if_user_is_authenticated([])
119 | assert conn.halted
120 | assert redirected_to(conn) == "/"
121 | end
122 |
123 | test "does not redirect if user is not authenticated", %{conn: conn} do
124 | conn = UserAuth.redirect_if_user_is_authenticated(conn, [])
125 | refute conn.halted
126 | refute conn.status
127 | end
128 | end
129 |
130 | describe "require_authenticated_user/2" do
131 | test "redirects if user is not authenticated", %{conn: conn} do
132 | conn = conn |> fetch_flash() |> UserAuth.require_authenticated_user([])
133 | assert conn.halted
134 | assert redirected_to(conn) == Routes.user_session_path(conn, :new)
135 | assert get_flash(conn, :error) == "You must log in to access this page."
136 | end
137 |
138 | test "stores the path to redirect to on GET", %{conn: conn} do
139 | halted_conn =
140 | %{conn | path_info: ["foo"], query_string: ""}
141 | |> fetch_flash()
142 | |> UserAuth.require_authenticated_user([])
143 |
144 | assert halted_conn.halted
145 | assert get_session(halted_conn, :user_return_to) == "/foo"
146 |
147 | halted_conn =
148 | %{conn | path_info: ["foo"], query_string: "bar=baz"}
149 | |> fetch_flash()
150 | |> UserAuth.require_authenticated_user([])
151 |
152 | assert halted_conn.halted
153 | assert get_session(halted_conn, :user_return_to) == "/foo?bar=baz"
154 |
155 | halted_conn =
156 | %{conn | path_info: ["foo"], query_string: "bar", method: "POST"}
157 | |> fetch_flash()
158 | |> UserAuth.require_authenticated_user([])
159 |
160 | assert halted_conn.halted
161 | refute get_session(halted_conn, :user_return_to)
162 | end
163 |
164 | test "does not redirect if user is authenticated", %{conn: conn, user: user} do
165 | conn = conn |> assign(:current_user, user) |> UserAuth.require_authenticated_user([])
166 | refute conn.halted
167 | refute conn.status
168 | end
169 | end
170 | end
171 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/controllers/user_confirmation_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserConfirmationControllerTest do
2 | use SqliteScaleWeb.ConnCase
3 |
4 | alias SqliteScale.Accounts
5 | alias SqliteScale.Repo
6 | import SqliteScale.AccountsFixtures
7 |
8 | setup do
9 | %{user: user_fixture()}
10 | end
11 |
12 | describe "GET /users/confirm" do
13 | test "renders the resend confirmation page", %{conn: conn} do
14 | conn = get(conn, Routes.user_confirmation_path(conn, :new))
15 | response = html_response(conn, 200)
16 | assert response =~ "
Resend confirmation instructions
"
17 | end
18 | end
19 |
20 | describe "POST /users/confirm" do
21 | @tag :capture_log
22 | test "sends a new confirmation token", %{conn: conn, user: user} do
23 | conn =
24 | post(conn, Routes.user_confirmation_path(conn, :create), %{
25 | "user" => %{"email" => user.email}
26 | })
27 |
28 | assert redirected_to(conn) == "/"
29 | assert get_flash(conn, :info) =~ "If your email is in our system"
30 | assert Repo.get_by!(Accounts.UserToken, user_id: user.id).context == "confirm"
31 | end
32 |
33 | test "does not send confirmation token if User is confirmed", %{conn: conn, user: user} do
34 | Repo.update!(Accounts.User.confirm_changeset(user))
35 |
36 | conn =
37 | post(conn, Routes.user_confirmation_path(conn, :create), %{
38 | "user" => %{"email" => user.email}
39 | })
40 |
41 | assert redirected_to(conn) == "/"
42 | assert get_flash(conn, :info) =~ "If your email is in our system"
43 | refute Repo.get_by(Accounts.UserToken, user_id: user.id)
44 | end
45 |
46 | test "does not send confirmation token if email is invalid", %{conn: conn} do
47 | conn =
48 | post(conn, Routes.user_confirmation_path(conn, :create), %{
49 | "user" => %{"email" => "unknown@example.com"}
50 | })
51 |
52 | assert redirected_to(conn) == "/"
53 | assert get_flash(conn, :info) =~ "If your email is in our system"
54 | assert Repo.all(Accounts.UserToken) == []
55 | end
56 | end
57 |
58 | describe "GET /users/confirm/:token" do
59 | test "renders the confirmation page", %{conn: conn} do
60 | conn = get(conn, Routes.user_confirmation_path(conn, :edit, "some-token"))
61 | response = html_response(conn, 200)
62 | assert response =~ "
Confirm account
"
63 |
64 | form_action = Routes.user_confirmation_path(conn, :update, "some-token")
65 | assert response =~ "action=\"#{form_action}\""
66 | end
67 | end
68 |
69 | describe "POST /users/confirm/:token" do
70 | test "confirms the given token once", %{conn: conn, user: user} do
71 | token =
72 | extract_user_token(fn url ->
73 | Accounts.deliver_user_confirmation_instructions(user, url)
74 | end)
75 |
76 | conn = post(conn, Routes.user_confirmation_path(conn, :update, token))
77 | assert redirected_to(conn) == "/"
78 | assert get_flash(conn, :info) =~ "User confirmed successfully"
79 | assert Accounts.get_user!(user.id).confirmed_at
80 | refute get_session(conn, :user_token)
81 | assert Repo.all(Accounts.UserToken) == []
82 |
83 | # When not logged in
84 | conn = post(conn, Routes.user_confirmation_path(conn, :update, token))
85 | assert redirected_to(conn) == "/"
86 | assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired"
87 |
88 | # When logged in
89 | conn =
90 | build_conn()
91 | |> log_in_user(user)
92 | |> post(Routes.user_confirmation_path(conn, :update, token))
93 |
94 | assert redirected_to(conn) == "/"
95 | refute get_flash(conn, :error)
96 | end
97 |
98 | test "does not confirm email with invalid token", %{conn: conn, user: user} do
99 | conn = post(conn, Routes.user_confirmation_path(conn, :update, "oops"))
100 | assert redirected_to(conn) == "/"
101 | assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired"
102 | refute Accounts.get_user!(user.id).confirmed_at
103 | end
104 | end
105 | end
106 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/controllers/user_registration_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserRegistrationControllerTest do
2 | use SqliteScaleWeb.ConnCase
3 |
4 | import SqliteScale.AccountsFixtures
5 |
6 | describe "GET /users/register" do
7 | test "renders registration page", %{conn: conn} do
8 | conn = get(conn, Routes.user_registration_path(conn, :new))
9 | response = html_response(conn, 200)
10 | assert response =~ "
Register
"
11 | assert response =~ "Log in"
12 | assert response =~ "Register"
13 | end
14 |
15 | test "redirects if already logged in", %{conn: conn} do
16 | conn = conn |> log_in_user(user_fixture()) |> get(Routes.user_registration_path(conn, :new))
17 | assert redirected_to(conn) == "/"
18 | end
19 | end
20 |
21 | describe "POST /users/register" do
22 | @tag :capture_log
23 | test "creates account and logs the user in", %{conn: conn} do
24 | email = unique_user_email()
25 |
26 | conn =
27 | post(conn, Routes.user_registration_path(conn, :create), %{
28 | "user" => valid_user_attributes(email: email)
29 | })
30 |
31 | assert get_session(conn, :user_token)
32 | assert redirected_to(conn) == "/"
33 |
34 | # Now do a logged in request and assert on the menu
35 | conn = get(conn, "/")
36 | response = html_response(conn, 200)
37 | assert response =~ email
38 | assert response =~ "Settings"
39 | assert response =~ "Log out"
40 | end
41 |
42 | test "render errors for invalid data", %{conn: conn} do
43 | conn =
44 | post(conn, Routes.user_registration_path(conn, :create), %{
45 | "user" => %{"email" => "with spaces", "password" => "too short"}
46 | })
47 |
48 | response = html_response(conn, 200)
49 | assert response =~ "
Register
"
50 | assert response =~ "must have the @ sign and no spaces"
51 | assert response =~ "should be at least 12 character"
52 | end
53 | end
54 | end
55 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/controllers/user_reset_password_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserResetPasswordControllerTest do
2 | use SqliteScaleWeb.ConnCase
3 |
4 | alias SqliteScale.Accounts
5 | alias SqliteScale.Repo
6 | import SqliteScale.AccountsFixtures
7 |
8 | setup do
9 | %{user: user_fixture()}
10 | end
11 |
12 | describe "GET /users/reset_password" do
13 | test "renders the reset password page", %{conn: conn} do
14 | conn = get(conn, Routes.user_reset_password_path(conn, :new))
15 | response = html_response(conn, 200)
16 | assert response =~ "
Forgot your password?
"
17 | end
18 | end
19 |
20 | describe "POST /users/reset_password" do
21 | @tag :capture_log
22 | test "sends a new reset password token", %{conn: conn, user: user} do
23 | conn =
24 | post(conn, Routes.user_reset_password_path(conn, :create), %{
25 | "user" => %{"email" => user.email}
26 | })
27 |
28 | assert redirected_to(conn) == "/"
29 | assert get_flash(conn, :info) =~ "If your email is in our system"
30 | assert Repo.get_by!(Accounts.UserToken, user_id: user.id).context == "reset_password"
31 | end
32 |
33 | test "does not send reset password token if email is invalid", %{conn: conn} do
34 | conn =
35 | post(conn, Routes.user_reset_password_path(conn, :create), %{
36 | "user" => %{"email" => "unknown@example.com"}
37 | })
38 |
39 | assert redirected_to(conn) == "/"
40 | assert get_flash(conn, :info) =~ "If your email is in our system"
41 | assert Repo.all(Accounts.UserToken) == []
42 | end
43 | end
44 |
45 | describe "GET /users/reset_password/:token" do
46 | setup %{user: user} do
47 | token =
48 | extract_user_token(fn url ->
49 | Accounts.deliver_user_reset_password_instructions(user, url)
50 | end)
51 |
52 | %{token: token}
53 | end
54 |
55 | test "renders reset password", %{conn: conn, token: token} do
56 | conn = get(conn, Routes.user_reset_password_path(conn, :edit, token))
57 | assert html_response(conn, 200) =~ "
Reset password
"
58 | end
59 |
60 | test "does not render reset password with invalid token", %{conn: conn} do
61 | conn = get(conn, Routes.user_reset_password_path(conn, :edit, "oops"))
62 | assert redirected_to(conn) == "/"
63 | assert get_flash(conn, :error) =~ "Reset password link is invalid or it has expired"
64 | end
65 | end
66 |
67 | describe "PUT /users/reset_password/:token" do
68 | setup %{user: user} do
69 | token =
70 | extract_user_token(fn url ->
71 | Accounts.deliver_user_reset_password_instructions(user, url)
72 | end)
73 |
74 | %{token: token}
75 | end
76 |
77 | test "resets password once", %{conn: conn, user: user, token: token} do
78 | conn =
79 | put(conn, Routes.user_reset_password_path(conn, :update, token), %{
80 | "user" => %{
81 | "password" => "new valid password",
82 | "password_confirmation" => "new valid password"
83 | }
84 | })
85 |
86 | assert redirected_to(conn) == Routes.user_session_path(conn, :new)
87 | refute get_session(conn, :user_token)
88 | assert get_flash(conn, :info) =~ "Password reset successfully"
89 | assert Accounts.get_user_by_email_and_password(user.email, "new valid password")
90 | end
91 |
92 | test "does not reset password on invalid data", %{conn: conn, token: token} do
93 | conn =
94 | put(conn, Routes.user_reset_password_path(conn, :update, token), %{
95 | "user" => %{
96 | "password" => "too short",
97 | "password_confirmation" => "does not match"
98 | }
99 | })
100 |
101 | response = html_response(conn, 200)
102 | assert response =~ "
Reset password
"
103 | assert response =~ "should be at least 12 character(s)"
104 | assert response =~ "does not match password"
105 | end
106 |
107 | test "does not reset password with invalid token", %{conn: conn} do
108 | conn = put(conn, Routes.user_reset_password_path(conn, :update, "oops"))
109 | assert redirected_to(conn) == "/"
110 | assert get_flash(conn, :error) =~ "Reset password link is invalid or it has expired"
111 | end
112 | end
113 | end
114 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/controllers/user_session_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserSessionControllerTest do
2 | use SqliteScaleWeb.ConnCase
3 |
4 | import SqliteScale.AccountsFixtures
5 |
6 | setup do
7 | %{user: user_fixture()}
8 | end
9 |
10 | describe "GET /users/log_in" do
11 | test "renders log in page", %{conn: conn} do
12 | conn = get(conn, Routes.user_session_path(conn, :new))
13 | response = html_response(conn, 200)
14 | assert response =~ "
Log in
"
15 | assert response =~ "Register"
16 | assert response =~ "Forgot your password?"
17 | end
18 |
19 | test "redirects if already logged in", %{conn: conn, user: user} do
20 | conn = conn |> log_in_user(user) |> get(Routes.user_session_path(conn, :new))
21 | assert redirected_to(conn) == "/"
22 | end
23 | end
24 |
25 | describe "POST /users/log_in" do
26 | test "logs the user in", %{conn: conn, user: user} do
27 | conn =
28 | post(conn, Routes.user_session_path(conn, :create), %{
29 | "user" => %{"email" => user.email, "password" => valid_user_password()}
30 | })
31 |
32 | assert get_session(conn, :user_token)
33 | assert redirected_to(conn) == "/"
34 |
35 | # Now do a logged in request and assert on the menu
36 | conn = get(conn, "/")
37 | response = html_response(conn, 200)
38 | assert response =~ user.email
39 | assert response =~ "Settings"
40 | assert response =~ "Log out"
41 | end
42 |
43 | test "logs the user in with remember me", %{conn: conn, user: user} do
44 | conn =
45 | post(conn, Routes.user_session_path(conn, :create), %{
46 | "user" => %{
47 | "email" => user.email,
48 | "password" => valid_user_password(),
49 | "remember_me" => "true"
50 | }
51 | })
52 |
53 | assert conn.resp_cookies["_sqlite_scale_web_user_remember_me"]
54 | assert redirected_to(conn) == "/"
55 | end
56 |
57 | test "logs the user in with return to", %{conn: conn, user: user} do
58 | conn =
59 | conn
60 | |> init_test_session(user_return_to: "/foo/bar")
61 | |> post(Routes.user_session_path(conn, :create), %{
62 | "user" => %{
63 | "email" => user.email,
64 | "password" => valid_user_password()
65 | }
66 | })
67 |
68 | assert redirected_to(conn) == "/foo/bar"
69 | end
70 |
71 | test "emits error message with invalid credentials", %{conn: conn, user: user} do
72 | conn =
73 | post(conn, Routes.user_session_path(conn, :create), %{
74 | "user" => %{"email" => user.email, "password" => "invalid_password"}
75 | })
76 |
77 | response = html_response(conn, 200)
78 | assert response =~ "
Log in
"
79 | assert response =~ "Invalid email or password"
80 | end
81 | end
82 |
83 | describe "DELETE /users/log_out" do
84 | test "logs the user out", %{conn: conn, user: user} do
85 | conn = conn |> log_in_user(user) |> delete(Routes.user_session_path(conn, :delete))
86 | assert redirected_to(conn) == "/"
87 | refute get_session(conn, :user_token)
88 | assert get_flash(conn, :info) =~ "Logged out successfully"
89 | end
90 |
91 | test "succeeds even if the user is not logged in", %{conn: conn} do
92 | conn = delete(conn, Routes.user_session_path(conn, :delete))
93 | assert redirected_to(conn) == "/"
94 | refute get_session(conn, :user_token)
95 | assert get_flash(conn, :info) =~ "Logged out successfully"
96 | end
97 | end
98 | end
99 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/controllers/user_settings_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.UserSettingsControllerTest do
2 | use SqliteScaleWeb.ConnCase
3 |
4 | alias SqliteScale.Accounts
5 | import SqliteScale.AccountsFixtures
6 |
7 | setup :register_and_log_in_user
8 |
9 | describe "GET /users/settings" do
10 | test "renders settings page", %{conn: conn} do
11 | conn = get(conn, Routes.user_settings_path(conn, :edit))
12 | response = html_response(conn, 200)
13 | assert response =~ "
Settings
"
14 | end
15 |
16 | test "redirects if user is not logged in" do
17 | conn = build_conn()
18 | conn = get(conn, Routes.user_settings_path(conn, :edit))
19 | assert redirected_to(conn) == Routes.user_session_path(conn, :new)
20 | end
21 | end
22 |
23 | describe "PUT /users/settings (change password form)" do
24 | test "updates the user password and resets tokens", %{conn: conn, user: user} do
25 | new_password_conn =
26 | put(conn, Routes.user_settings_path(conn, :update), %{
27 | "action" => "update_password",
28 | "current_password" => valid_user_password(),
29 | "user" => %{
30 | "password" => "new valid password",
31 | "password_confirmation" => "new valid password"
32 | }
33 | })
34 |
35 | assert redirected_to(new_password_conn) == Routes.user_settings_path(conn, :edit)
36 | assert get_session(new_password_conn, :user_token) != get_session(conn, :user_token)
37 | assert get_flash(new_password_conn, :info) =~ "Password updated successfully"
38 | assert Accounts.get_user_by_email_and_password(user.email, "new valid password")
39 | end
40 |
41 | test "does not update password on invalid data", %{conn: conn} do
42 | old_password_conn =
43 | put(conn, Routes.user_settings_path(conn, :update), %{
44 | "action" => "update_password",
45 | "current_password" => "invalid",
46 | "user" => %{
47 | "password" => "too short",
48 | "password_confirmation" => "does not match"
49 | }
50 | })
51 |
52 | response = html_response(old_password_conn, 200)
53 | assert response =~ "
Settings
"
54 | assert response =~ "should be at least 12 character(s)"
55 | assert response =~ "does not match password"
56 | assert response =~ "is not valid"
57 |
58 | assert get_session(old_password_conn, :user_token) == get_session(conn, :user_token)
59 | end
60 | end
61 |
62 | describe "PUT /users/settings (change email form)" do
63 | @tag :capture_log
64 | test "updates the user email", %{conn: conn, user: user} do
65 | conn =
66 | put(conn, Routes.user_settings_path(conn, :update), %{
67 | "action" => "update_email",
68 | "current_password" => valid_user_password(),
69 | "user" => %{"email" => unique_user_email()}
70 | })
71 |
72 | assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
73 | assert get_flash(conn, :info) =~ "A link to confirm your email"
74 | assert Accounts.get_user_by_email(user.email)
75 | end
76 |
77 | test "does not update email on invalid data", %{conn: conn} do
78 | conn =
79 | put(conn, Routes.user_settings_path(conn, :update), %{
80 | "action" => "update_email",
81 | "current_password" => "invalid",
82 | "user" => %{"email" => "with spaces"}
83 | })
84 |
85 | response = html_response(conn, 200)
86 | assert response =~ "
Settings
"
87 | assert response =~ "must have the @ sign and no spaces"
88 | assert response =~ "is not valid"
89 | end
90 | end
91 |
92 | describe "GET /users/settings/confirm_email/:token" do
93 | setup %{user: user} do
94 | email = unique_user_email()
95 |
96 | token =
97 | extract_user_token(fn url ->
98 | Accounts.deliver_update_email_instructions(%{user | email: email}, user.email, url)
99 | end)
100 |
101 | %{token: token, email: email}
102 | end
103 |
104 | test "updates the user email once", %{conn: conn, user: user, token: token, email: email} do
105 | conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token))
106 | assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
107 | assert get_flash(conn, :info) =~ "Email changed successfully"
108 | refute Accounts.get_user_by_email(user.email)
109 | assert Accounts.get_user_by_email(email)
110 |
111 | conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token))
112 | assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
113 | assert get_flash(conn, :error) =~ "Email change link is invalid or it has expired"
114 | end
115 |
116 | test "does not update email with invalid token", %{conn: conn, user: user} do
117 | conn = get(conn, Routes.user_settings_path(conn, :confirm_email, "oops"))
118 | assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
119 | assert get_flash(conn, :error) =~ "Email change link is invalid or it has expired"
120 | assert Accounts.get_user_by_email(user.email)
121 | end
122 |
123 | test "redirects if user is not logged in", %{token: token} do
124 | conn = build_conn()
125 | conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token))
126 | assert redirected_to(conn) == Routes.user_session_path(conn, :new)
127 | end
128 | end
129 | end
130 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/views/error_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.ErrorViewTest do
2 | use SqliteScaleWeb.ConnCase, async: true
3 |
4 | # Bring render/3 and render_to_string/3 for testing custom views
5 | import Phoenix.View
6 |
7 | test "renders 404.html" do
8 | assert render_to_string(SqliteScaleWeb.ErrorView, "404.html", []) == "Not Found"
9 | end
10 |
11 | test "renders 500.html" do
12 | assert render_to_string(SqliteScaleWeb.ErrorView, "500.html", []) == "Internal Server Error"
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.LayoutViewTest do
2 | use SqliteScaleWeb.ConnCase, async: true
3 |
4 | # When testing helpers, you may want to import Phoenix.HTML and
5 | # use functions such as safe_to_string() to convert the helper
6 | # result into an HTML string.
7 | # import Phoenix.HTML
8 | end
9 |
--------------------------------------------------------------------------------
/test/sqlite_scale_web/views/page_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.PageViewTest do
2 | use SqliteScaleWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/test/support/channel_case.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.ChannelCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | channel tests.
5 |
6 | Such tests rely on `Phoenix.ChannelTest` and also
7 | import other functionality to make it easier
8 | to build common data structures and query the data layer.
9 |
10 | Finally, if the test case interacts with the database,
11 | we enable the SQL sandbox, so changes done to the database
12 | are reverted at the end of every test. If you are using
13 | PostgreSQL, you can even run database tests asynchronously
14 | by setting `use SqliteScaleWeb.ChannelCase, async: true`, although
15 | this option is not recommended for other databases.
16 | """
17 |
18 | use ExUnit.CaseTemplate
19 |
20 | using do
21 | quote do
22 | # Import conveniences for testing with channels
23 | import Phoenix.ChannelTest
24 | import SqliteScaleWeb.ChannelCase
25 |
26 | # The default endpoint for testing
27 | @endpoint SqliteScaleWeb.Endpoint
28 | end
29 | end
30 |
31 | setup tags do
32 | pid = Ecto.Adapters.SQL.Sandbox.start_owner!(SqliteScale.Repo, shared: not tags[:async])
33 | on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end)
34 | :ok
35 | end
36 | end
37 |
--------------------------------------------------------------------------------
/test/support/conn_case.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScaleWeb.ConnCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | tests that require setting up a connection.
5 |
6 | Such tests rely on `Phoenix.ConnTest` and also
7 | import other functionality to make it easier
8 | to build common data structures and query the data layer.
9 |
10 | Finally, if the test case interacts with the database,
11 | we enable the SQL sandbox, so changes done to the database
12 | are reverted at the end of every test. If you are using
13 | PostgreSQL, you can even run database tests asynchronously
14 | by setting `use SqliteScaleWeb.ConnCase, async: true`, although
15 | this option is not recommended for other databases.
16 | """
17 |
18 | use ExUnit.CaseTemplate
19 |
20 | using do
21 | quote do
22 | # Import conveniences for testing with connections
23 | import Plug.Conn
24 | import Phoenix.ConnTest
25 | import SqliteScaleWeb.ConnCase
26 |
27 | alias SqliteScaleWeb.Router.Helpers, as: Routes
28 |
29 | # The default endpoint for testing
30 | @endpoint SqliteScaleWeb.Endpoint
31 | end
32 | end
33 |
34 | setup tags do
35 | pid = Ecto.Adapters.SQL.Sandbox.start_owner!(SqliteScale.Repo, shared: not tags[:async])
36 | on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end)
37 | {:ok, conn: Phoenix.ConnTest.build_conn()}
38 | end
39 |
40 | @doc """
41 | Setup helper that registers and logs in users.
42 |
43 | setup :register_and_log_in_user
44 |
45 | It stores an updated connection and a registered user in the
46 | test context.
47 | """
48 | def register_and_log_in_user(%{conn: conn}) do
49 | user = SqliteScale.AccountsFixtures.user_fixture()
50 | %{conn: log_in_user(conn, user), user: user}
51 | end
52 |
53 | @doc """
54 | Logs the given `user` into the `conn`.
55 |
56 | It returns an updated `conn`.
57 | """
58 | def log_in_user(conn, user) do
59 | token = SqliteScale.Accounts.generate_user_session_token(user)
60 |
61 | conn
62 | |> Phoenix.ConnTest.init_test_session(%{})
63 | |> Plug.Conn.put_session(:user_token, token)
64 | end
65 | end
66 |
--------------------------------------------------------------------------------
/test/support/data_case.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScale.DataCase do
2 | @moduledoc """
3 | This module defines the setup for tests requiring
4 | access to the application's data layer.
5 |
6 | You may define functions here to be used as helpers in
7 | your tests.
8 |
9 | Finally, if the test case interacts with the database,
10 | we enable the SQL sandbox, so changes done to the database
11 | are reverted at the end of every test. If you are using
12 | PostgreSQL, you can even run database tests asynchronously
13 | by setting `use SqliteScale.DataCase, async: true`, although
14 | this option is not recommended for other databases.
15 | """
16 |
17 | use ExUnit.CaseTemplate
18 |
19 | using do
20 | quote do
21 | alias SqliteScale.Repo
22 |
23 | import Ecto
24 | import Ecto.Changeset
25 | import Ecto.Query
26 | import SqliteScale.DataCase
27 | end
28 | end
29 |
30 | setup tags do
31 | pid = Ecto.Adapters.SQL.Sandbox.start_owner!(SqliteScale.Repo, shared: not tags[:async])
32 | on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end)
33 | :ok
34 | end
35 |
36 | @doc """
37 | A helper that transforms changeset errors into a map of messages.
38 |
39 | assert {:error, changeset} = Accounts.create_user(%{password: "short"})
40 | assert "password is too short" in errors_on(changeset).password
41 | assert %{password: ["password is too short"]} = errors_on(changeset)
42 |
43 | """
44 | def errors_on(changeset) do
45 | Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
46 | Regex.replace(~r"%{(\w+)}", message, fn _, key ->
47 | opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
48 | end)
49 | end)
50 | end
51 | end
52 |
--------------------------------------------------------------------------------
/test/support/fixtures/accounts_fixtures.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScale.AccountsFixtures do
2 | @moduledoc """
3 | This module defines test helpers for creating
4 | entities via the `SqliteScale.Accounts` context.
5 | """
6 |
7 | def unique_user_email, do: "user#{System.unique_integer()}@example.com"
8 | def valid_user_password, do: "hello world!"
9 |
10 | def valid_user_attributes(attrs \\ %{}) do
11 | Enum.into(attrs, %{
12 | email: unique_user_email(),
13 | password: valid_user_password()
14 | })
15 | end
16 |
17 | def user_fixture(attrs \\ %{}) do
18 | {:ok, user} =
19 | attrs
20 | |> valid_user_attributes()
21 | |> SqliteScale.Accounts.register_user()
22 |
23 | user
24 | end
25 |
26 | def extract_user_token(fun) do
27 | {:ok, captured_email} = fun.(&"[TOKEN]#{&1}[TOKEN]")
28 | [_, token | _] = String.split(captured_email.text_body, "[TOKEN]")
29 | token
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/test/support/fixtures/todo_items_fixtures.ex:
--------------------------------------------------------------------------------
1 | defmodule SqliteScale.TodoItemsFixtures do
2 | @moduledoc """
3 | This module defines test helpers for creating
4 | entities via the `SqliteScale.TodoItems` context.
5 | """
6 |
7 | @doc """
8 | Generate a todo_item.
9 | """
10 | def todo_item_fixture(attrs \\ %{}) do
11 | {:ok, todo_item} =
12 | attrs
13 | |> Enum.into(%{
14 | item: "some item"
15 | })
16 | |> SqliteScale.TodoItems.create_todo_item()
17 |
18 | todo_item
19 | end
20 | end
21 |
--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 | Ecto.Adapters.SQL.Sandbox.mode(SqliteScale.Repo, :manual)
3 |
--------------------------------------------------------------------------------