31 |
32 |
33 |
38 |
--------------------------------------------------------------------------------
/app/lib/match_web/templates/session/index.html.eex:
--------------------------------------------------------------------------------
1 |
145 |
--------------------------------------------------------------------------------
/app/lib/match_web/templates/session/new.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
"/>
5 |
6 |
30 |
31 |
32 |
33 |
38 |
--------------------------------------------------------------------------------
/app/lib/match_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.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), class: "help-block")
14 | end)
15 | end
16 |
17 | @doc """
18 | Translates an error message using gettext.
19 | """
20 | def translate_error({msg, opts}) do
21 | # When using gettext, we typically pass the strings we want
22 | # to translate as a static argument:
23 | #
24 | # # Translate "is invalid" in the "errors" domain
25 | # dgettext("errors", "is invalid")
26 | #
27 | # # Translate the number of files with plural rules
28 | # dngettext("errors", "1 file", "%{count} files", count)
29 | #
30 | # Because the error messages we show in our forms and APIs
31 | # are defined inside Ecto, we need to translate them dynamically.
32 | # This requires us to call the Gettext module passing our gettext
33 | # backend as first argument.
34 | #
35 | # Note we use the "errors" domain, which means translations
36 | # should be written to the errors.po file. The :count option is
37 | # set by Ecto and indicates we should also apply plural rules.
38 | if count = opts[:count] do
39 | Gettext.dngettext(MatchWeb.Gettext, "errors", msg, msg, count, opts)
40 | else
41 | Gettext.dgettext(MatchWeb.Gettext, "errors", msg, opts)
42 | end
43 | end
44 | end
45 |
--------------------------------------------------------------------------------
/app/lib/match_web/views/error_view.ex:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.ErrorView do
2 | use MatchWeb, :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 |
--------------------------------------------------------------------------------
/app/lib/match_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.LayoutView do
2 | use MatchWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/app/lib/match_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.PageView do
2 | use MatchWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/app/lib/match_web/views/registration_view.ex:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.RegistrationView do
2 | use MatchWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/app/lib/match_web/views/session_view.ex:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.SessionView do
2 | use MatchWeb, :view
3 | end
4 |
--------------------------------------------------------------------------------
/app/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.MixProject do
2 | use Mix.Project
3 |
4 | def project do
5 | [
6 | app: :match,
7 | version: "0.1.0",
8 | elixir: "~> 1.5",
9 | elixirc_paths: elixirc_paths(Mix.env()),
10 | compilers: [:phoenix, :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: {Match.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 | {:phoenix, "~> 1.4.2", override: true},
37 | {:phoenix_pubsub, "~> 1.1"},
38 | {:phoenix_ecto, "~> 4.0"},
39 | {:ecto_sql, "~> 3.0"},
40 | {:postgrex, ">= 0.0.0"},
41 | {:phoenix_html, "~> 2.11"},
42 | {:phoenix_live_reload, "~> 1.2", only: :dev},
43 | {:gettext, "~> 0.11"},
44 | {:jason, "~> 1.0"},
45 | {:plug_cowboy, "~> 2.0"},
46 | {:bcrypt_elixir, "~> 1.1"},
47 | {:floki, "~> 0.20.0"},
48 | {:phoenix_live_view, github: "phoenixframework/phoenix_live_view"},
49 | {:mix_test_watch, "~> 0.8", only: :dev, runtime: false}
50 | ]
51 | end
52 |
53 | # Aliases are shortcuts or tasks specific to the current project.
54 | # For example, to create, migrate and run the seeds file at once:
55 | #
56 | # $ mix ecto.setup
57 | #
58 | # See the documentation for `Mix` for more info on aliases.
59 | defp aliases do
60 | [
61 | "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
62 | "ecto.reset": ["ecto.drop", "ecto.setup"],
63 | test: ["ecto.create --quiet", "ecto.migrate", "test"]
64 | ]
65 | end
66 | end
67 |
--------------------------------------------------------------------------------
/app/mix.lock:
--------------------------------------------------------------------------------
1 | %{
2 | "bcrypt_elixir": {:hex, :bcrypt_elixir, "1.1.1", "6b5560e47a02196ce5f0ab3f1d8265db79a23868c137e973b27afef928ed8006", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm"},
3 | "connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"},
4 | "cowboy": {:hex, :cowboy, "2.6.1", "f2e06f757c337b3b311f9437e6e072b678fcd71545a7b2865bdaa154d078593f", [:rebar3], [{:cowlib, "~> 2.7.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.7.1", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm"},
5 | "cowlib": {:hex, :cowlib, "2.7.0", "3ef16e77562f9855a2605900cedb15c1462d76fb1be6a32fc3ae91973ee543d2", [:rebar3], [], "hexpm"},
6 | "db_connection": {:hex, :db_connection, "2.0.6", "bde2f85d047969c5b5800cb8f4b3ed6316c8cb11487afedac4aa5f93fd39abfa", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"},
7 | "decimal": {:hex, :decimal, "1.7.0", "30d6b52c88541f9a66637359ddf85016df9eb266170d53105f02e4a67e00c5aa", [:mix], [], "hexpm"},
8 | "ecto": {:hex, :ecto, "3.1.0", "42e669e172df63a0db37ece40be2dc2fc8698854436d2a9ce84375ddf221c1cb", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
9 | "ecto_sql": {:hex, :ecto_sql, "3.1.0", "20d773799db0ed112dc4109305df679f1c8b0a59cf75e6d15ee05656af5bd708", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.1.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:myxql, "~> 0.2.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
10 | "elixir_make": {:hex, :elixir_make, "0.5.2", "96a28c79f5b8d34879cd95ebc04d2a0d678cfbbd3e74c43cb63a76adf0ee8054", [:mix], [], "hexpm"},
11 | "file_system": {:hex, :file_system, "0.2.6", "fd4dc3af89b9ab1dc8ccbcc214a0e60c41f34be251d9307920748a14bf41f1d3", [:mix], [], "hexpm"},
12 | "floki": {:hex, :floki, "0.20.4", "be42ac911fece24b4c72f3b5846774b6e61b83fe685c2fc9d62093277fb3bc86", [:mix], [{:html_entities, "~> 0.4.0", [hex: :html_entities, repo: "hexpm", optional: false]}, {:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
13 | "gettext": {:hex, :gettext, "0.16.1", "e2130b25eebcbe02bb343b119a07ae2c7e28bd4b146c4a154da2ffb2b3507af2", [:mix], [], "hexpm"},
14 | "html_entities": {:hex, :html_entities, "0.4.0", "f2fee876858cf6aaa9db608820a3209e45a087c5177332799592142b50e89a6b", [:mix], [], "hexpm"},
15 | "jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
16 | "mime": {:hex, :mime, "1.3.1", "30ce04ab3175b6ad0bdce0035cba77bba68b813d523d1aac73d9781b4d193cf8", [:mix], [], "hexpm"},
17 | "mix_test_watch": {:hex, :mix_test_watch, "0.9.0", "c72132a6071261893518fa08e121e911c9358713f62794a90c95db59042af375", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}], "hexpm"},
18 | "mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
19 | "phoenix": {:hex, :phoenix, "1.4.3", "8eed4a64ff1e12372cd634724bddd69185938f52c18e1396ebac76375d85677d", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}], "hexpm"},
20 | "phoenix_ecto": {:hex, :phoenix_ecto, "4.0.0", "c43117a136e7399ea04ecaac73f8f23ee0ffe3e07acfcb8062fe5f4c9f0f6531", [:mix], [{:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
21 | "phoenix_html": {:hex, :phoenix_html, "2.13.2", "f5d27c9b10ce881a60177d2b5227314fc60881e6b66b41dfe3349db6ed06cf57", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
22 | "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.2.0", "3bb31a9fbd40ffe8652e60c8660dffd72dd231efcdf49b744fb75b9ef7db5dd2", [: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"},
23 | "phoenix_live_view": {:git, "https://github.com/phoenixframework/phoenix_live_view.git", "f6d63c518a189fb789fd871a3f5b82e3dbe7ecb3", []},
24 | "phoenix_pubsub": {:hex, :phoenix_pubsub, "1.1.2", "496c303bdf1b2e98a9d26e89af5bba3ab487ba3a3735f74bf1f4064d2a845a3e", [:mix], [], "hexpm"},
25 | "plug": {:hex, :plug, "1.8.0", "9d2685cb007fe5e28ed9ac27af2815bc262b7817a00929ac10f56f169f43b977", [:mix], [{:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm"},
26 | "plug_cowboy": {:hex, :plug_cowboy, "2.0.2", "6055f16868cc4882b24b6e1d63d2bada94fb4978413377a3b32ac16c18dffba2", [:mix], [{:cowboy, "~> 2.5", [hex: :cowboy, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
27 | "plug_crypto": {:hex, :plug_crypto, "1.0.0", "18e49317d3fa343f24620ed22795ec29d4a5e602d52d1513ccea0b07d8ea7d4d", [:mix], [], "hexpm"},
28 | "postgrex": {:hex, :postgrex, "0.14.1", "63247d4a5ad6b9de57a0bac5d807e1c32d41e39c04b8a4156a26c63bcd8a2e49", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
29 | "ranch": {:hex, :ranch, "1.7.1", "6b1fab51b49196860b733a49c07604465a47bdb78aa10c1c16a3d199f7f8c881", [:rebar3], [], "hexpm"},
30 | "telemetry": {:hex, :telemetry, "0.4.0", "8339bee3fa8b91cb84d14c2935f8ecf399ccd87301ad6da6b71c09553834b2ab", [:rebar3], [], "hexpm"},
31 | }
32 |
--------------------------------------------------------------------------------
/app/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 be %{count} character(s)"
54 | msgid_plural "should be %{count} character(s)"
55 | msgstr[0] ""
56 | msgstr[1] ""
57 |
58 | msgid "should have %{count} item(s)"
59 | msgid_plural "should have %{count} item(s)"
60 | msgstr[0] ""
61 | msgstr[1] ""
62 |
63 | msgid "should be at least %{count} character(s)"
64 | msgid_plural "should be at least %{count} character(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 most %{count} character(s)"
74 | msgid_plural "should be at most %{count} character(s)"
75 | msgstr[0] ""
76 | msgstr[1] ""
77 |
78 | msgid "should have at most %{count} item(s)"
79 | msgid_plural "should have at most %{count} item(s)"
80 | msgstr[0] ""
81 | msgstr[1] ""
82 |
83 | ## From Ecto.Changeset.validate_number/3
84 | msgid "must be less than %{number}"
85 | msgstr ""
86 |
87 | msgid "must be greater than %{number}"
88 | msgstr ""
89 |
90 | msgid "must be less than or equal to %{number}"
91 | msgstr ""
92 |
93 | msgid "must be greater than or equal to %{number}"
94 | msgstr ""
95 |
96 | msgid "must be equal to %{number}"
97 | msgstr ""
98 |
--------------------------------------------------------------------------------
/app/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 |
--------------------------------------------------------------------------------
/app/priv/repo/migrations/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 | import_deps: [:ecto_sql],
3 | inputs: ["*.exs"]
4 | ]
5 |
--------------------------------------------------------------------------------
/app/priv/repo/migrations/20190222211932_create_users.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.Repo.Migrations.CreateUsers do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:users, primary_key: false) do
6 | add :id, :string, primary_key: true
7 | add :username, :string
8 | add :hash, :string
9 | add :icon, :string
10 |
11 | timestamps()
12 | end
13 |
14 | create unique_index(:users, [:username])
15 | end
16 | end
17 |
--------------------------------------------------------------------------------
/app/priv/repo/migrations/20190222214752_create_statistics.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.Repo.Migrations.CreateStatistics do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:statistics, primary_key: false) do
6 | add :user, :string, primary_key: true
7 | add :wins, :integer
8 | add :flips, :integer
9 |
10 | timestamps()
11 | end
12 |
13 | create unique_index(:statistics, [:user])
14 | end
15 | end
16 |
--------------------------------------------------------------------------------
/app/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 | # Match.Repo.insert!(%Match.SomeSchema{})
9 | #
10 | # We recommend using the bang functions (`insert!`, `update!`
11 | # and so on) as they will fail if something goes wrong.
12 |
--------------------------------------------------------------------------------
/app/priv/static/css/app.css:
--------------------------------------------------------------------------------
1 | html {
2 | color: White;
3 | font-size: 16px;
4 | font-family: 'Roboto', sans-serif;
5 | font-weight: 400;
6 | box-sizing: border-box;
7 | font-smoothing: antialiased;
8 | -webkit-font-smoothing: antialiased;
9 | -moz-osx-font-smoothing: grayscale;
10 | }
11 |
12 | *, *:before, *:after {
13 | box-sizing: inherit;
14 | }
15 |
16 | body {
17 | margin: 0;
18 | overflow-y: hidden;
19 | }
20 |
21 | .animate {
22 | transition: all 0.1s;
23 | -webkit-transition: all 0.1s;
24 | }
25 |
26 | .margin-right {
27 | margin-right: 15px;
28 | }
29 |
30 | .icon-padding {
31 | padding-left: 40px;
32 | padding-right: 30px;
33 | }
34 |
35 | .action-button {
36 | padding: 10px 40px;
37 | border-radius: 5px;
38 | font-size: 24px;
39 | color: #FFF;
40 | text-decoration: none;
41 | }
42 |
43 | .public {
44 | background-size: 35px;
45 | background-position: left;
46 | background-repeat: no-repeat;
47 | }
48 |
49 | .private {
50 | background-size: 35px;
51 | background-position: left;
52 | background-repeat: no-repeat;
53 | }
54 |
55 | .play {
56 | background-image: url("/images/play.svg");
57 | background-size: 30px;
58 | background-position: center;
59 | background-repeat: no-repeat;
60 | padding: 20px;
61 | padding-bottom: 5px;
62 | padding-top: 5px;
63 | }
64 |
65 | .green {
66 | background-color: rgba(76, 175, 80, 0.8);
67 | }
68 |
69 | .purple {
70 | background-color: rgba(195, 109, 216, 1);
71 | }
72 |
73 | .index-container {
74 | display: flex;
75 | justify-content: center;
76 | }
77 |
78 | .index {
79 | display: flex;
80 | max-width: 1025px;
81 | }
82 |
83 | .logo {
84 | flex: 2 0 0;
85 | height: 786px;
86 | padding-top: 10px;
87 | }
88 |
89 | .logo img {
90 | max-width: 100%;
91 | }
92 |
93 | .flex {
94 | display: flex;
95 | flex: 1 0 0;
96 | }
97 |
98 | .options {
99 | height: 786px;
100 | background: rgba(147,209,245, 0.9);
101 | background: -webkit-linear-gradient(right, rgba(147,209,245, 0.9), #bde0ff);
102 | background: linear-gradient(right, rgba(147,209,245, 0.9), #bde0ff);
103 | }
104 |
105 | .intro-container {
106 | width: 400px;
107 | display: flex;
108 | flex-direction: column;
109 | justify-content: center;
110 | color: #505b5e;
111 | }
112 |
113 | .intro-header {
114 | padding-left: 40px;
115 | padding-right: 40px;
116 | }
117 |
118 | .intro-header h1 {
119 | font-family: 'Aclonica', sans-serif;
120 | word-break: break-word;
121 | font-size: 5em;
122 | }
123 |
124 | .intro-text {
125 | margin-top: -58px;
126 | padding-left: 40px;
127 | padding-right: 40px;
128 | }
129 |
130 | .intro-text p {
131 | line-height: 1.4em;
132 | font-size: 1.4em;
133 | }
134 |
135 | .intro-header-login {
136 | color: #505b5e;
137 | padding-left: 20px;
138 | padding-right: 20px;
139 | margin-top: -100px;
140 | }
141 |
142 | .intro-header-login h1 {
143 | font-family: 'Aclonica', sans-serif;
144 | word-break: break-word;
145 | font-size: 5em;
146 | }
147 |
148 | .intro {
149 | width: 350px;
150 | margin: 16px auto;
151 | font-size: 16px;
152 | }
153 |
154 | .card-game {
155 | width: 100%;
156 | height: 100%;
157 | background: rgb(147,209,245);
158 | }
159 |
160 | .game-container {
161 | display: flex;
162 | justify-content: center;
163 | text-align: center;
164 | }
165 |
166 | .sticky-header {
167 | position:-webkit-sticky;
168 | position:sticky;
169 | top:0;
170 | display: flex;
171 | justify-content: center;
172 | z-index: 3;
173 | }
174 |
175 | .phoenix-header {
176 | margin: auto;
177 | position: fixed;
178 | right: 0;
179 | left: 0;
180 | z-index: 3;
181 | }
182 |
183 | .phoenix-header .header {
184 | font-weight: bold;
185 | padding-left: 25px;
186 | padding-right: 25px;
187 | }
188 |
189 | .sticky-header .header {
190 | font-weight: bold;
191 | padding-left: 25px;
192 | padding-right: 25px;
193 | }
194 |
195 | .header {
196 | text-align: center;
197 | color: #fff;
198 | border-bottom-right-radius: 5px;
199 | border-bottom-left-radius: 5px;
200 | border: 3px solid rgba(70,86,88, 0.9);
201 | box-shadow: rgba(0,0,0,0.8) 0 0 4px;
202 | background: rgba(97,111,114, 0.8);
203 | border-top: 0;
204 | font-size: 1.5em;
205 | letter-spacing: 1px;
206 | line-height: 1em;
207 | padding-top: 0.6em;
208 | padding-bottom: 0.5em;
209 | font-weight: 200;
210 | }
211 |
212 | .header-game {
213 | min-width: 500px;
214 | font-family: 'Aclonica', sans-serif;
215 | }
216 |
217 | .label {
218 | color: #00ff0a;
219 | }
220 |
221 | .alert-danger {
222 | background: rgba(240, 91, 116, 0.9);
223 | text-transform: capitalize;
224 | }
225 |
226 | .alert-success {
227 | background: rgba(76, 175, 80, 0.9);
228 | text-transform: capitalize;
229 | }
230 |
231 | .alert {
232 | text-align: center;
233 | color: #fff;
234 | font-family: 'Roboto', sans-serif;
235 | padding-top: 0.8em;
236 | padding-bottom: 0.8em;
237 | }
238 |
239 | .login-container {
240 | width: 400px;
241 | display: flex;
242 | justify-content: center;
243 | align-items: center;
244 | }
245 |
246 | .login-page {
247 | width: 350px;
248 | }
249 | .form {
250 | background: #FFFFFF;
251 | padding: 45px;
252 | text-align: center;
253 | box-shadow: 0 0 20px 0 rgba(0, 0, 0, 0.2), 0 5px 5px 0 rgba(0, 0, 0, 0.24);
254 | }
255 | .form input {
256 | outline: 0;
257 | background: #f2f2f2;
258 | width: 100%;
259 | border: 0;
260 | margin: 0 0 15px;
261 | padding: 15px;
262 | box-sizing: border-box;
263 | font-size: 14px;
264 | }
265 | .form button {
266 | text-transform: uppercase;
267 | outline: 0;
268 | background: #7eb6d6;
269 | width: 100%;
270 | border: 0;
271 | padding: 15px;
272 | color: #FFFFFF;
273 | font-size: 14px;
274 | -webkit-transition: all 0.3 ease;
275 | transition: all 0.3 ease;
276 | cursor: pointer;
277 | }
278 | .form button:hover,.form button:active,.form button:focus {
279 | background: #86bfd4;
280 | }
281 | .form .message {
282 | margin: 15px 0 0;
283 | color: #b3b3b3;
284 | font-size: 12px;
285 | }
286 | .form .message a {
287 | color: #4CAF50;
288 | text-decoration: none;
289 | }
290 | .form .optional-form {
291 | display: none;
292 | }
293 |
294 | .ten-more {
295 | padding-top: 10px;
296 | }
297 |
298 | .twenty-more {
299 | padding-top: 20px;
300 | }
301 |
302 | .start-join-container {
303 | font-family: 'Aclonica', sans-serif;
304 | color: #505b5e;
305 | width: 400px;
306 | display: flex;
307 | justify-content: space-evenly;
308 | align-items: center;
309 | }
310 |
311 | .links-container {
312 | padding-top: 5px;
313 | width: 400px;
314 | display: flex;
315 | justify-content: space-evenly;
316 | align-items: center;
317 | }
318 |
319 | .links-intro-padding {
320 | padding-top: 20px;
321 | padding-bottom: 25px;
322 | }
323 |
324 | .links {
325 | padding: 0;
326 | margin: 0;
327 | }
328 |
329 | .games-container {
330 | width: 400px;
331 | display: flex;
332 | justify-content: center;
333 | align-items: center;
334 | }
335 |
336 | .game {
337 | max-width: 1025px;
338 | }
339 |
340 | .games {
341 | width: 350px;
342 | }
343 |
344 | .filter-container {
345 | background: #FFFFFF;
346 | box-shadow: 0 0 20px 0 rgba(0, 0, 0, 0.2), 0 5px 5px 0 rgba(0, 0, 0, 0.24);
347 | }
348 |
349 | .filter-form input::-webkit-input-placeholder {
350 | font-weight: 300;
351 | color: #7c8b8f;
352 | }
353 |
354 | .filter-form input::-moz-placeholder {
355 | font-weight: 300;
356 | color: #7c8b8f;
357 | }
358 |
359 | .filter-form input::input-placeholder {
360 | font-weight: 300;
361 | color: #7c8b8f;
362 | }
363 |
364 | .filter-games {
365 | box-sizing: border-box;
366 | line-height: 1.4em;
367 | font-size: 24px;
368 | width: 100%;
369 | padding: 16px 16px 16px 20px;
370 | border: none;
371 | background: rgba(0, 0, 0, 0.003);
372 | color: #505b5e;
373 | }
374 |
375 | .available {
376 | max-height: 478px;
377 | overflow: hidden;
378 | overflow-x: hidden;
379 | background: #FFFFFF;
380 | box-shadow: 0 0 20px 0 rgba(0, 0, 0, 0.2), 0 5px 5px 0 rgba(0, 0, 0, 0.24);
381 | }
382 |
383 | .games-list {
384 | margin: 0;
385 | padding: 0;
386 | list-style: none;
387 | }
388 |
389 | .games-list li {
390 | width: 100%;
391 | font-size: 24px;
392 | border-bottom: 1px solid #ededed;
393 | padding-bottom: 15px;
394 | display: inline-block;
395 | background: url("/images/profile.png") no-repeat;
396 | overflow: hidden;
397 | }
398 |
399 | .games-list li:first-child {
400 | margin-top: 4px;
401 | }
402 |
403 | .games-list li:last-child {
404 | border-bottom: none;
405 | }
406 |
407 | .games h1 {
408 | width: 100%;
409 | color: rgba(80,91,94, .8);
410 | text-rendering: optimizeLegibility;
411 | font-size: 45px;
412 | font-weight: 100;
413 | text-align: center;
414 | }
415 |
416 | .available-container {
417 | display: flex;
418 | }
419 |
420 | .games-list li .title {
421 | color: #505b5e;
422 | word-break: break-all;
423 | padding-top: 8px;
424 | padding-bottom: 7px;
425 | padding-left: 85px;
426 | text-transform: uppercase;
427 | font-size: .8em;
428 | }
429 |
430 | .games-list li .username {
431 | font-family: 'Aclonica', sans-serif;
432 | display: block;
433 | }
434 |
435 | .games-list li .created {
436 | font-size: .7em;
437 | display: inline-block;
438 | color: #7c8b8f;
439 | }
440 |
441 | .games-list li .play-icon {
442 | align-self: center;
443 | margin-left: auto;
444 | margin-right: 10px;
445 | }
446 |
447 | .games-list li .nada {
448 | word-break: break-all;
449 | padding: 20px;
450 | display: block;
451 | line-height: 1.2;
452 | transition: color 0.4s;
453 | text-align: center;
454 | }
455 |
456 | .games-list li.no-games {
457 | text-align: center;
458 | font-weight: 300;
459 | color: #7c8b8f;
460 | background: none;
461 | padding-bottom: 0;
462 | }
463 |
464 | .games-list li.one {
465 | background-position: 0 1px;
466 | }
467 |
468 | .games-list li.two {
469 | background-position: 0 -75px;
470 | }
471 |
472 | .games-list li.three {
473 | background-position: 0 -150px;
474 | }
475 |
476 | .games-list li.four {
477 | background-position: 0 -226px;
478 | }
479 |
480 | .games-list li.five {
481 | background-position: 0 -300px;
482 | }
483 |
484 | .games-list li.six {
485 | background-position: 0 -374px;
486 | }
487 |
488 | .games-list li.seven {
489 | background-position: 0 -448px;
490 | }
491 |
492 | .games-list li.eight {
493 | background-position: 0 -525px;
494 | }
495 |
496 | .games-list li.nine {
497 | background-position: 0 -600px;
498 | }
499 |
500 | .games-list li.ten {
501 | background-position: 0 -674px;
502 | }
503 |
504 | .games-list li.eleven {
505 | background-position: 0 -749px;
506 | }
507 |
508 | .games-list li.twelve {
509 | background-position: 0 -823px;
510 | }
511 |
512 | .games-list li.thirteen {
513 | background-position: 0 -897px;
514 | }
515 |
516 | .games-list li.fourteen {
517 | background-position: 0 -973px;
518 | }
519 |
520 | .splash .overlay {
521 | position: absolute;
522 | left: 0;
523 | right: 0;
524 | top: 0;
525 | bottom: 0;
526 | background-color: rgba(0, 0, 0, 0.6);
527 | }
528 |
529 | .splash .content h1 {
530 | color: #00ff0a;
531 | font-size: 1.7em;
532 | padding: 30px;
533 | padding-top: 10px;
534 | padding-bottom: 25px;
535 | text-transform: uppercase;
536 | font-family: 'Aclonica', sans-serif;
537 | }
538 |
539 | .splash .content h2 {
540 | color: #ffffff;
541 | padding-bottom: 20px;
542 | font-family: 'Aclonica', sans-serif;
543 | }
544 |
545 | .splash .content {
546 | position: absolute;
547 | left: 0;
548 | right: 0;
549 | top: 0;
550 | bottom: 0;
551 | width: 425px;
552 | height: 250px;
553 | margin: auto;
554 | text-align: center;
555 | background-color: rgba(51, 51, 51, 0.9);
556 | -moz-border-radius: 5px;
557 | -webkit-border-radius: 5px;
558 | border-radius: 5px;
559 | -moz-box-shadow: 5px 5px 20px rgba(0, 0, 0, 0.8);
560 | -webkit-box-shadow: 5px 5px 20px rgba(0, 0, 0, 0.8);
561 | box-shadow: 5px 5px 20px rgba(0, 0, 0, 0.8);
562 | }
563 |
564 | .joined {
565 | padding-top: 20px;
566 | padding-bottom: 20px;
567 | }
568 |
569 | .score {
570 | padding-left: 10px;
571 | }
572 |
573 | @media only screen and (min-width : 414px) {
574 | .games-container {
575 | width: 414px;
576 | }
577 | .intro-container {
578 | width: 414px;
579 | }
580 | .login-container {
581 | width: 414px;
582 | }
583 | .start-join-container {
584 | width: 414px;
585 | }
586 | .links-container {
587 | width: 414px;
588 | }
589 | }
590 |
591 | @media only screen and (min-width : 415px) {
592 | .phoenix-header {
593 | max-width: 470px;
594 | }
595 | }
596 |
597 | .cards .card {
598 | position: relative;
599 | display: inline-block;
600 | width: 100px;
601 | height: 150px;
602 | margin: 2em;
603 | -moz-transition: opacity 0.5s;
604 | -o-transition: opacity 0.5s;
605 | -webkit-transition: opacity 0.5s;
606 | transition: opacity 0.5s;
607 | }
608 |
609 | .cards .card .front, .cards .card .back {
610 | border-radius: 5px;
611 | position: absolute;
612 | left: 0;
613 | right: 0;
614 | top: 0;
615 | bottom: 0;
616 | width: 100%;
617 | height: 100%;
618 | background-color: White;
619 | -moz-backface-visibility: hidden;
620 | -webkit-backface-visibility: hidden;
621 | backface-visibility: hidden;
622 | -moz-transform: translateZ(0);
623 | -ms-transform: translateZ(0);
624 | -webkit-transform: translateZ(0);
625 | transform: translateZ(0);
626 | -moz-transition: -moz-transform 0.6s;
627 | -o-transition: -o-transform 0.6s;
628 | -webkit-transition: -webkit-transform 0.6s;
629 | transition: transform 0.6s;
630 | -moz-transform-style: preserve-3d;
631 | -webkit-transform-style: preserve-3d;
632 | transform-style: preserve-3d;
633 | }
634 |
635 | .cards .card .back {
636 | background-image: url("/images/card.jpg");
637 | background-size: 90%;
638 | background-position: center;
639 | background-repeat: no-repeat;
640 | font-size: 12px;
641 | }
642 |
643 | .cards .card .front {
644 | -moz-transform: rotateY(-180deg);
645 | -ms-transform: rotateY(-180deg);
646 | -webkit-transform: rotateY(-180deg);
647 | transform: rotateY(-180deg);
648 | background-size: 90%;
649 | background-repeat: no-repeat;
650 | background-position: center;
651 | }
652 |
653 | .cards .card.flipped .back, .cards .card.found .back {
654 | -moz-transform: rotateY(180deg);
655 | -ms-transform: rotateY(180deg);
656 | -webkit-transform: rotateY(180deg);
657 | transform: rotateY(180deg);
658 | }
659 |
660 | .cards .card.flipped .front, .cards .card.found .front {
661 | -moz-transform: rotateY(0deg);
662 | -ms-transform: rotateY(0deg);
663 | -webkit-transform: rotateY(0deg);
664 | transform: rotateY(0deg);
665 | }
666 |
667 | .cards .card.found {
668 | opacity: 0.3;
669 | }
670 |
671 | .inactive {
672 | visibility: hidden;
673 | };
674 |
--------------------------------------------------------------------------------
/app/priv/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/favicon.ico
--------------------------------------------------------------------------------
/app/priv/static/images/card.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/card.jpg
--------------------------------------------------------------------------------
/app/priv/static/images/cards/eight.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/eight.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/eleven.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/eleven.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/fifteen.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/fifteen.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/five.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/five.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/four.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/four.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/fourteen.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/fourteen.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/nine.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/nine.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/one.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/one.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/seven.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/seven.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/six.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/six.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/ten.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/ten.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/thirteen.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/thirteen.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/three.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/three.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/twelve.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/twelve.png
--------------------------------------------------------------------------------
/app/priv/static/images/cards/two.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/cards/two.png
--------------------------------------------------------------------------------
/app/priv/static/images/elixir.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/elixir.png
--------------------------------------------------------------------------------
/app/priv/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/phoenix.png
--------------------------------------------------------------------------------
/app/priv/static/images/play.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
--------------------------------------------------------------------------------
/app/priv/static/images/profile.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toranb/elixir-match/c63c94055688efa55ce62f3070fa01e08de7f6e3/app/priv/static/images/profile.png
--------------------------------------------------------------------------------
/app/priv/static/js/app.js:
--------------------------------------------------------------------------------
1 | // for phoenix_html support, including form and button helpers
2 | // copy the following scripts into your javascript bundle:
3 | // * https://raw.githubusercontent.com/phoenixframework/phoenix_html/v2.10.0/priv/static/phoenix_html.js
4 |
--------------------------------------------------------------------------------
/app/priv/static/js/phoenix.js:
--------------------------------------------------------------------------------
1 | !function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.Phoenix=t():e.Phoenix=t()}(window,function(){return function(e){var t={};function n(i){if(t[i])return t[i].exports;var o=t[i]={i:i,l:!1,exports:{}};return e[i].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=e,n.c=t,n.d=function(e,t,i){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:i})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var i=Object.create(null);if(n.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)n.d(i,o,function(t){return e[t]}.bind(null,o));return i},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=0)}([function(e,t,n){(function(t){e.exports=t.Phoenix=n(2)}).call(this,n(1))},function(e,t){var n;n=function(){return this}();try{n=n||Function("return this")()||(0,eval)("this")}catch(e){"object"==typeof window&&(n=window)}e.exports=n},function(e,t,n){"use strict";function i(e){return function(e){if(Array.isArray(e)){for(var t=0,n=new Array(e.length);t
0&&void 0!==arguments[0]?arguments[0]:this.timeout;if(this.joinedOnce)throw"tried to join multiple times. 'join' can only be called a single time per channel instance";return this.joinedOnce=!0,this.rejoin(e),this.joinPush}},{key:"onClose",value:function(e){this.on(p.close,e)}},{key:"onError",value:function(e){return this.on(p.error,function(t){return e(t)})}},{key:"on",value:function(e,t){var n=this.bindingRef++;return this.bindings.push({event:e,ref:n,callback:t}),n}},{key:"off",value:function(e,t){this.bindings=this.bindings.filter(function(n){return!(n.event===e&&(void 0===t||t===n.ref))})}},{key:"canPush",value:function(){return this.socket.isConnected()&&this.isJoined()}},{key:"push",value:function(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:this.timeout;if(!this.joinedOnce)throw"tried to push '".concat(e,"' to '").concat(this.topic,"' before joining. Use channel.join() before pushing events");var i=new m(this,e,function(){return t},n);return this.canPush()?i.send():(i.startTimeout(),this.pushBuffer.push(i)),i}},{key:"leave",value:function(){var e=this,t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:this.timeout;this.state=f.leaving;var n=function(){e.socket.hasLogger()&&e.socket.log("channel","leave ".concat(e.topic)),e.trigger(p.close,"leave")},i=new m(this,p.leave,y({}),t);return i.receive("ok",function(){return n()}).receive("timeout",function(){return n()}),i.send(),this.canPush()||i.trigger("ok",{}),i}},{key:"onMessage",value:function(e,t,n){return t}},{key:"isLifecycleEvent",value:function(e){return d.indexOf(e)>=0}},{key:"isMember",value:function(e,t,n,i){return this.topic===e&&(!i||i===this.joinRef()||!this.isLifecycleEvent(t)||(this.socket.hasLogger()&&this.socket.log("channel","dropping outdated message",{topic:e,event:t,payload:n,joinRef:i}),!1))}},{key:"joinRef",value:function(){return this.joinPush.ref}},{key:"sendJoin",value:function(e){this.state=f.joining,this.joinPush.resend(e)}},{key:"rejoin",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:this.timeout;this.isLeaving()||this.sendJoin(e)}},{key:"trigger",value:function(e,t,n,i){var o=this.onMessage(e,t,n,i);if(t&&!o)throw"channel onMessage callbacks must return the payload, modified or unmodified";for(var r=0;r1&&void 0!==arguments[1]?arguments[1]:{};s(this,e),this.stateChangeCallbacks={open:[],close:[],error:[],message:[]},this.channels=[],this.sendBuffer=[],this.ref=0,this.timeout=i.timeout||l,this.transport=i.transport||u.WebSocket||j,this.defaultEncoder=k.encode,this.defaultDecoder=k.decode,this.transport!==j?(this.encode=i.encode||this.defaultEncoder,this.decode=i.decode||this.defaultDecoder):(this.encode=this.defaultEncoder,this.decode=this.defaultDecoder),this.heartbeatIntervalMs=i.heartbeatIntervalMs||3e4,this.reconnectAfterMs=i.reconnectAfterMs||function(e){return[1e3,2e3,5e3,1e4][e-1]||1e4},this.logger=i.logger||null,this.longpollerTimeout=i.longpollerTimeout||2e4,this.params=y(i.params||{}),this.endPoint="".concat(t,"/").concat(v.websocket),this.heartbeatTimer=null,this.pendingHeartbeatRef=null,this.reconnectTimer=new C(function(){n.teardown(function(){return n.connect()})},this.reconnectAfterMs)}return c(e,[{key:"protocol",value:function(){return location.protocol.match(/^https/)?"wss":"ws"}},{key:"endPointURL",value:function(){var e=R.appendParams(R.appendParams(this.endPoint,this.params()),{vsn:"2.0.0"});return"/"!==e.charAt(0)?e:"/"===e.charAt(1)?"".concat(this.protocol(),":").concat(e):"".concat(this.protocol(),"://").concat(location.host).concat(e)}},{key:"disconnect",value:function(e,t,n){this.reconnectTimer.reset(),this.teardown(e,t,n)}},{key:"connect",value:function(e){var t=this;e&&(console&&console.log("passing params to connect is deprecated. Instead pass :params to the Socket constructor"),this.params=y(e)),this.conn||(this.conn=new this.transport(this.endPointURL()),this.conn.timeout=this.longpollerTimeout,this.conn.onopen=function(){return t.onConnOpen()},this.conn.onerror=function(e){return t.onConnError(e)},this.conn.onmessage=function(e){return t.onConnMessage(e)},this.conn.onclose=function(e){return t.onConnClose(e)})}},{key:"log",value:function(e,t,n){this.logger(e,t,n)}},{key:"hasLogger",value:function(){return null!==this.logger}},{key:"onOpen",value:function(e){this.stateChangeCallbacks.open.push(e)}},{key:"onClose",value:function(e){this.stateChangeCallbacks.close.push(e)}},{key:"onError",value:function(e){this.stateChangeCallbacks.error.push(e)}},{key:"onMessage",value:function(e){this.stateChangeCallbacks.message.push(e)}},{key:"onConnOpen",value:function(){this.hasLogger()&&this.log("transport","connected to ".concat(this.endPointURL())),this.flushSendBuffer(),this.reconnectTimer.reset(),this.resetHeartbeat(),this.resetChannelTimers(),this.stateChangeCallbacks.open.forEach(function(e){return e()})}},{key:"resetHeartbeat",value:function(){var e=this;this.conn.skipHeartbeat||(this.pendingHeartbeatRef=null,clearInterval(this.heartbeatTimer),this.heartbeatTimer=setInterval(function(){return e.sendHeartbeat()},this.heartbeatIntervalMs))}},{key:"teardown",value:function(e,t,n){this.conn&&(this.conn.onclose=function(){},t?this.conn.close(t,n||""):this.conn.close(),this.conn=null),e&&e()}},{key:"onConnClose",value:function(e){this.hasLogger()&&this.log("transport","close",e),this.triggerChanError(),clearInterval(this.heartbeatTimer),e&&1e3!==e.code&&this.reconnectTimer.scheduleTimeout(),this.stateChangeCallbacks.close.forEach(function(t){return t(e)})}},{key:"onConnError",value:function(e){this.hasLogger()&&this.log("transport",e),this.triggerChanError(),this.stateChangeCallbacks.error.forEach(function(t){return t(e)})}},{key:"triggerChanError",value:function(){this.channels.forEach(function(e){return e.trigger(p.error)})}},{key:"connectionState",value:function(){switch(this.conn&&this.conn.readyState){case h.connecting:return"connecting";case h.open:return"open";case h.closing:return"closing";default:return"closed"}}},{key:"isConnected",value:function(){return"open"===this.connectionState()}},{key:"remove",value:function(e){this.channels=this.channels.filter(function(t){return t.joinRef()!==e.joinRef()})}},{key:"channel",value:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=new g(e,t,this);return this.channels.push(n),n}},{key:"push",value:function(e){var t=this;if(this.hasLogger()){var n=e.topic,i=e.event,o=e.payload,r=e.ref,s=e.join_ref;this.log("push","".concat(n," ").concat(i," (").concat(s,", ").concat(r,")"),o)}this.isConnected()?this.encode(e,function(e){return t.conn.send(e)}):this.sendBuffer.push(function(){return t.encode(e,function(e){return t.conn.send(e)})})}},{key:"makeRef",value:function(){var e=this.ref+1;return e===this.ref?this.ref=0:this.ref=e,this.ref.toString()}},{key:"sendHeartbeat",value:function(){if(this.isConnected()){if(this.pendingHeartbeatRef)return this.pendingHeartbeatRef=null,this.hasLogger()&&this.log("transport","heartbeat timeout. Attempting to re-establish connection"),void this.conn.close(1e3,"hearbeat timeout");this.pendingHeartbeatRef=this.makeRef(),this.push({topic:"phoenix",event:"heartbeat",payload:{},ref:this.pendingHeartbeatRef})}}},{key:"flushSendBuffer",value:function(){this.isConnected()&&this.sendBuffer.length>0&&(this.sendBuffer.forEach(function(e){return e()}),this.sendBuffer=[])}},{key:"onConnMessage",value:function(e){var t=this;this.decode(e.data,function(e){var n=e.topic,i=e.event,o=e.payload,r=e.ref,s=e.join_ref;r&&r===t.pendingHeartbeatRef&&(t.pendingHeartbeatRef=null),t.hasLogger()&&t.log("receive","".concat(o.status||""," ").concat(n," ").concat(i," ").concat(r&&"("+r+")"||""),o);for(var a=0;a1&&void 0!==arguments[1]?arguments[1]:{};s(this,e);var o=i.events||{state:"presence_state",diff:"presence_diff"};this.state={},this.pendingDiffs=[],this.channel=t,this.joinRef=null,this.caller={onJoin:function(){},onLeave:function(){},onSync:function(){}},this.channel.on(o.state,function(t){var i=n.caller,o=i.onJoin,r=i.onLeave,s=i.onSync;n.joinRef=n.channel.joinRef(),n.state=e.syncState(n.state,t,o,r),n.pendingDiffs.forEach(function(t){n.state=e.syncDiff(n.state,t,o,r)}),n.pendingDiffs=[],s()}),this.channel.on(o.diff,function(t){var i=n.caller,o=i.onJoin,r=i.onLeave,s=i.onSync;n.inPendingSyncState()?n.pendingDiffs.push(t):(n.state=e.syncDiff(n.state,t,o,r),s())})}return c(e,[{key:"onJoin",value:function(e){this.caller.onJoin=e}},{key:"onLeave",value:function(e){this.caller.onLeave=e}},{key:"onSync",value:function(e){this.caller.onSync=e}},{key:"list",value:function(t){return e.list(this.state,t)}},{key:"inPendingSyncState",value:function(){return!this.joinRef||this.joinRef!==this.channel.joinRef()}}],[{key:"syncState",value:function(e,t,n,i){var o=this,r=this.clone(e),s={},a={};return this.map(r,function(e,n){t[e]||(a[e]=n)}),this.map(t,function(e,t){var n=r[e];if(n){var i=t.metas.map(function(e){return e.phx_ref}),c=n.metas.map(function(e){return e.phx_ref}),u=t.metas.filter(function(e){return c.indexOf(e.phx_ref)<0}),h=n.metas.filter(function(e){return i.indexOf(e.phx_ref)<0});u.length>0&&(s[e]=t,s[e].metas=u),h.length>0&&(a[e]=o.clone(n),a[e].metas=h)}else s[e]=t}),this.syncDiff(r,{joins:s,leaves:a},n,i)}},{key:"syncDiff",value:function(e,t,n,o){var r=t.joins,s=t.leaves,a=this.clone(e);return n||(n=function(){}),o||(o=function(){}),this.map(r,function(e,t){var o=a[e];if(a[e]=t,o){var r,s=a[e].metas.map(function(e){return e.phx_ref}),c=o.metas.filter(function(e){return s.indexOf(e.phx_ref)<0});(r=a[e].metas).unshift.apply(r,i(c))}n(e,o,t)}),this.map(s,function(e,t){var n=a[e];if(n){var i=t.metas.map(function(e){return e.phx_ref});n.metas=n.metas.filter(function(e){return i.indexOf(e.phx_ref)<0}),o(e,n,t),0===n.metas.length&&delete a[e]}}),a}},{key:"list",value:function(e,t){return t||(t=function(e,t){return t}),this.map(e,function(e,n){return t(e,n)})}},{key:"map",value:function(e,t){return Object.getOwnPropertyNames(e).map(function(n){return t(n,e[n])})}},{key:"clone",value:function(e){return JSON.parse(JSON.stringify(e))}}]),e}(),C=function(){function e(t,n){s(this,e),this.callback=t,this.timerCalc=n,this.timer=null,this.tries=0}return c(e,[{key:"reset",value:function(){this.tries=0,this.clearTimer()}},{key:"restart",value:function(){var e=null!==this.timer;this.reset(),e&&this.scheduleTimeout()}},{key:"scheduleTimeout",value:function(){var e=this;this.clearTimer(),this.timer=setTimeout(function(){e.tries=e.tries+1,e.callback()},this.timerCalc(this.tries+1))}},{key:"clearTimer",value:function(){clearTimeout(this.timer),this.timer=null}}]),e}()}])});
--------------------------------------------------------------------------------
/app/priv/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://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 |
--------------------------------------------------------------------------------
/app/test/match/find_user_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.FindUserTest do
2 | use ExUnit.Case, async: true
3 |
4 | alias Match.Password
5 | alias Match.FindUser
6 |
7 | @user_one "A4E3400CF711E76BBD86C57CA"
8 | @user_two "EBDA4E3FDECD8F2759D96250A"
9 |
10 | test "find with username and password" do
11 | state = %{}
12 | icon = "one"
13 | username = "toranb"
14 | password = "abc123"
15 | password_hash = Password.hash(password)
16 |
17 | assert FindUser.with_username_and_password(state, username, password) === nil
18 |
19 | new_state = Map.put(state, @user_one, {username, icon, password_hash})
20 | assert FindUser.with_username_and_password(new_state, username, password) === @user_one
21 | assert FindUser.with_username_and_password(new_state, username, "abc12") === nil
22 |
23 | icon_two = "two"
24 | username_two = "jarrod"
25 | password_two = "def456"
26 | password_hash_two = Password.hash(password_two)
27 | last_state = Map.put(new_state, @user_two, {username_two, icon_two, password_hash_two})
28 | assert FindUser.with_username_and_password(last_state, username, password) === @user_one
29 | assert FindUser.with_username_and_password(last_state, username_two, password_two) === @user_two
30 | assert FindUser.with_username_and_password(last_state, username_two, "") === nil
31 | assert FindUser.with_username_and_password(last_state, username, password_two) === nil
32 | end
33 | end
34 |
--------------------------------------------------------------------------------
/app/test/match/game_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.GameTest do
2 | use ExUnit.Case, async: true
3 |
4 | test "new returns game struct with list of cards in random order" do
5 | state = Match.Game.new(2)
6 |
7 | %Match.Game{cards: cards, winner: winner, active_player_id: active_player_id, players: players} = state
8 |
9 | possible = [
10 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false},
11 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
12 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => false},
13 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
14 | %Match.Card{:id => "3F9A231", :name => "three", :image => "/images/cards/three.png", :flipped => false},
15 | %Match.Card{:id => "3F9A232", :name => "three", :image => "/images/cards/three.png", :flipped => false},
16 | %Match.Card{:id => "3F9AC51", :name => "four", :image => "/images/cards/four.png", :flipped => false},
17 | %Match.Card{:id => "3F9AC52", :name => "four", :image => "/images/cards/four.png", :flipped => false},
18 | %Match.Card{:id => "DA320E1", :name => "five", :image => "/images/cards/five.png", :flipped => false},
19 | %Match.Card{:id => "DA320E2", :name => "five", :image => "/images/cards/five.png", :flipped => false},
20 | %Match.Card{:id => "145AEF1", :name => "six", :image => "/images/cards/six.png", :flipped => false},
21 | %Match.Card{:id => "145AEF2", :name => "six", :image => "/images/cards/six.png", :flipped => false},
22 | %Match.Card{:id => "8808BC1", :name => "seven", :image => "/images/cards/seven.png", :flipped => false},
23 | %Match.Card{:id => "8808BC2", :name => "seven", :image => "/images/cards/seven.png", :flipped => false},
24 | %Match.Card{:id => "7720B41", :name => "eight", :image => "/images/cards/eight.png", :flipped => false},
25 | %Match.Card{:id => "7720B42", :name => "eight", :image => "/images/cards/eight.png", :flipped => false},
26 | %Match.Card{:id => "0073F91", :name => "nine", :image => "/images/cards/nine.png", :flipped => false},
27 | %Match.Card{:id => "0073F92", :name => "nine", :image => "/images/cards/nine.png", :flipped => false},
28 | %Match.Card{:id => "E6AAE31", :name => "ten", :image => "/images/cards/ten.png", :flipped => false},
29 | %Match.Card{:id => "E6AAE32", :name => "ten", :image => "/images/cards/ten.png", :flipped => false},
30 | %Match.Card{:id => "85C9871", :name => "eleven", :image => "/images/cards/eleven.png", :flipped => false},
31 | %Match.Card{:id => "85C9872", :name => "eleven", :image => "/images/cards/eleven.png", :flipped => false},
32 | %Match.Card{:id => "32252B1", :name => "twelve", :image => "/images/cards/twelve.png", :flipped => false},
33 | %Match.Card{:id => "32252B2", :name => "twelve", :image => "/images/cards/twelve.png", :flipped => false},
34 | %Match.Card{:id => "B9B1C01", :name => "thirteen", :image => "/images/cards/thirteen.png", :flipped => false},
35 | %Match.Card{:id => "B9B1C02", :name => "thirteen", :image => "/images/cards/thirteen.png", :flipped => false},
36 | %Match.Card{:id => "C4D0AD1", :name => "fourteen", :image => "/images/cards/fourteen.png", :flipped => false},
37 | %Match.Card{:id => "C4D0AD2", :name => "fourteen", :image => "/images/cards/fourteen.png", :flipped => false},
38 | %Match.Card{:id => "8F7E371", :name => "fifteen", :image => "/images/cards/fifteen.png", :flipped => false},
39 | %Match.Card{:id => "8F7E372", :name => "fifteen", :image => "/images/cards/fifteen.png", :flipped => false},
40 | ]
41 |
42 | [
43 | %Match.Card{id: id_one, name: name_one, image: image_one, flipped: flipped_one},
44 | %Match.Card{id: id_two, name: name_two, image: image_two, flipped: flipped_two},
45 | %Match.Card{id: id_three, name: name_three, image: image_three, flipped: flipped_three},
46 | %Match.Card{id: id_four, name: name_four, image: image_four, flipped: flipped_four}
47 | ] = cards
48 |
49 | assert Enum.count(cards) == 4
50 |
51 | %Match.Card{:name => name, :image => image, :flipped => flipped} = Enum.find(possible, fn(card) -> card.id === id_one end)
52 | assert name == name_one
53 | assert image == image_one
54 | assert flipped == flipped_one
55 |
56 | %Match.Card{:name => name, :image => image, :flipped => flipped} = Enum.find(possible, fn(card) -> card.id === id_two end)
57 | assert name == name_two
58 | assert image == image_two
59 | assert flipped == flipped_two
60 |
61 | %Match.Card{:name => name, :image => image, :flipped => flipped} = Enum.find(possible, fn(card) -> card.id === id_three end)
62 | assert name == name_three
63 | assert image == image_three
64 | assert flipped == flipped_three
65 |
66 | %Match.Card{:name => name, :image => image, :flipped => flipped} = Enum.find(possible, fn(card) -> card.id === id_four end)
67 | assert name == name_four
68 | assert image == image_four
69 | assert flipped == flipped_four
70 |
71 | assert winner == nil
72 | assert active_player_id == nil
73 | assert players == []
74 |
75 | another_state = Match.Game.new(2)
76 | %Match.Game{cards: another_cards} = another_state
77 | assert cards != another_cards
78 | end
79 |
80 | test "restart will keep active player along with players and unpair all cards" do
81 | state = %Match.Game{
82 | cards: [
83 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
84 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true, :paired => false},
85 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
86 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false, :paired => false},
87 | %Match.Card{:id => "3F9A231", :name => "three", :image => "/images/cards/three.png", :flipped => false, :paired => true},
88 | %Match.Card{:id => "3F9A232", :name => "three", :image => "/images/cards/three.png", :flipped => false, :paired => true},
89 | ],
90 | winner: nil,
91 | players: [
92 | "EBDA4E",
93 | "01D3CC"
94 | ],
95 | active_player_id: "01D3CC",
96 | scores: %{"EBDA4E" => 1, "01D3CC" => 1}
97 | }
98 |
99 | state = Match.Game.flip(state, "3079822", "01D3CC")
100 |
101 | %Match.Game{cards: cards, winner: winner, active_player_id: active_player_id, players: players, scores: scores} = state
102 |
103 | assert Enum.count(cards) == 6
104 | assert winner == "01D3CC"
105 | assert active_player_id == "01D3CC"
106 | assert players == ["EBDA4E", "01D3CC"]
107 | assert scores == %{"EBDA4E" => 1, "01D3CC" => 2}
108 | Enum.each(cards, fn (card) -> assert card.paired == true end)
109 |
110 | restarted = Match.Game.restart(state)
111 |
112 | %Match.Game{cards: cards, winner: winner, active_player_id: active_player_id, players: players, scores: scores} = restarted
113 |
114 | assert Enum.count(cards) == 6
115 | assert winner == nil
116 | assert active_player_id == "01D3CC"
117 | assert players == ["EBDA4E", "01D3CC"]
118 | assert scores == %{}
119 |
120 | Enum.each(cards, fn (card) -> assert card.paired == false end)
121 | end
122 |
123 | test "flip will mark a given card with flipped attribute" do
124 | state = %Match.Game{
125 | cards: [
126 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false},
127 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => false},
128 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
129 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
130 | ],
131 | winner: nil,
132 | players: [
133 | "EBDA4E",
134 | "01D3CC"
135 | ],
136 | active_player_id: "01D3CC"
137 | }
138 |
139 | new_state = Match.Game.flip(state, "3079821", "01D3CC")
140 |
141 | %Match.Game{cards: cards, winner: winner, scores: scores} = new_state
142 | [
143 | %Match.Card{flipped: flip_one},
144 | %Match.Card{flipped: flip_two},
145 | %Match.Card{flipped: flip_three},
146 | %Match.Card{flipped: flip_four}
147 | ] = cards
148 |
149 | assert flip_one == false
150 | assert flip_two == true
151 | assert flip_three == false
152 | assert flip_four == false
153 |
154 | assert winner == nil
155 | assert scores == %{}
156 | end
157 |
158 | test "flipping the 2nd card in a match will mark the cards as paired and revert flipped to false" do
159 | state = %Match.Game{
160 | cards: [
161 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false},
162 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true},
163 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
164 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
165 | ],
166 | winner: nil,
167 | players: [
168 | "EBDA4E",
169 | "01D3CC"
170 | ],
171 | active_player_id: "01D3CC"
172 | }
173 |
174 | new_state = Match.Game.flip(state, "3079822", "01D3CC")
175 |
176 | %Match.Game{cards: cards, winner: winner, scores: scores} = new_state
177 | [
178 | %Match.Card{flipped: flip_one, paired: paired_one},
179 | %Match.Card{flipped: flip_two, paired: paired_two},
180 | %Match.Card{flipped: flip_three, paired: paired_three},
181 | %Match.Card{flipped: flip_four, paired: paired_four},
182 | ] = cards
183 |
184 | assert flip_one == false
185 | assert flip_two == false
186 | assert flip_three == false
187 | assert flip_four == false
188 |
189 | assert paired_one == false
190 | assert paired_two == true
191 | assert paired_three == false
192 | assert paired_four == true
193 |
194 | assert winner == nil
195 | assert scores == %{"01D3CC" => 1}
196 | end
197 |
198 | test "flipping the 2nd card that is NOT a match will mark the cards as flipped but not paired" do
199 | state = %Match.Game{
200 | cards: [
201 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false},
202 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true},
203 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
204 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
205 | ],
206 | winner: nil,
207 | animating: false,
208 | players: [
209 | "EBDA4E",
210 | "01D3CC"
211 | ],
212 | active_player_id: "01D3CC"
213 | }
214 |
215 | new_state = Match.Game.flip(state, "24CEDF1", "01D3CC")
216 |
217 | %Match.Game{cards: cards, winner: winner, animating: animating} = new_state
218 | [
219 | %Match.Card{flipped: flip_one, paired: paired_one},
220 | %Match.Card{flipped: flip_two, paired: paired_two},
221 | %Match.Card{flipped: flip_three, paired: paired_three},
222 | %Match.Card{flipped: flip_four, paired: paired_four},
223 | ] = cards
224 |
225 | assert flip_one == true
226 | assert flip_two == true
227 | assert flip_three == false
228 | assert flip_four == false
229 |
230 | assert paired_one == false
231 | assert paired_two == false
232 | assert paired_three == false
233 | assert paired_four == false
234 |
235 | assert winner == nil
236 | assert animating == true
237 | end
238 |
239 | test "unflip will reset animating to false and revert any flipped cards" do
240 | state = %Match.Game{
241 | cards: [
242 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => true},
243 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true},
244 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
245 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
246 | ],
247 | winner: nil,
248 | animating: true,
249 | players: [
250 | "EBDA4E",
251 | "01D3CC"
252 | ],
253 | active_player_id: "01D3CC"
254 | }
255 |
256 | new_state = Match.Game.unflip(state)
257 |
258 | %Match.Game{cards: cards, winner: winner, animating: animating, active_player_id: active_player_id, players: players} = new_state
259 | [
260 | %Match.Card{flipped: flip_one, paired: paired_one},
261 | %Match.Card{flipped: flip_two, paired: paired_two},
262 | %Match.Card{flipped: flip_three, paired: paired_three},
263 | %Match.Card{flipped: flip_four, paired: paired_four},
264 | ] = cards
265 |
266 | [player_one, player_two] = players
267 |
268 | assert flip_one == false
269 | assert flip_two == false
270 | assert flip_three == false
271 | assert flip_four == false
272 |
273 | assert paired_one == false
274 | assert paired_two == false
275 | assert paired_three == false
276 | assert paired_four == false
277 |
278 | assert winner == nil
279 | assert animating == false
280 | assert active_player_id == "EBDA4E"
281 | assert player_one == "EBDA4E"
282 | assert player_two == "01D3CC"
283 | end
284 |
285 | test "flipping the last match will mark the winner as truthy and prepare restart will unflip/unpair each card" do
286 | state = %Match.Game{
287 | cards: [
288 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
289 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true, :paired => false},
290 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
291 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false, :paired => false},
292 | ],
293 | winner: nil,
294 | players: [
295 | "EBDA4E",
296 | "01D3CC"
297 | ],
298 | active_player_id: "01D3CC",
299 | scores: %{"EBDA4E" => 1, "01D3CC" => 1}
300 | }
301 |
302 | new_state = Match.Game.flip(state, "3079822", "01D3CC")
303 |
304 | %Match.Game{cards: cards, winner: winner, scores: scores} = new_state
305 | [
306 | %Match.Card{flipped: flip_one, paired: paired_one},
307 | %Match.Card{flipped: flip_two, paired: paired_two},
308 | %Match.Card{flipped: flip_three, paired: paired_three},
309 | %Match.Card{flipped: flip_four, paired: paired_four},
310 | ] = cards
311 |
312 | assert flip_one == false
313 | assert flip_two == false
314 | assert flip_three == false
315 | assert flip_four == false
316 |
317 | assert paired_one == true
318 | assert paired_two == true
319 | assert paired_three == true
320 | assert paired_four == true
321 |
322 | assert winner == "01D3CC"
323 | assert scores == %{"EBDA4E" => 1, "01D3CC" => 2}
324 |
325 | prepare_state = Match.Game.prepare_restart(new_state)
326 |
327 | %Match.Game{cards: cards, winner: winner, scores: scores} = prepare_state
328 | [
329 | %Match.Card{flipped: flip_one, paired: paired_one},
330 | %Match.Card{flipped: flip_two, paired: paired_two},
331 | %Match.Card{flipped: flip_three, paired: paired_three},
332 | %Match.Card{flipped: flip_four, paired: paired_four},
333 | ] = cards
334 |
335 | assert flip_one == false
336 | assert flip_two == false
337 | assert flip_three == false
338 | assert flip_four == false
339 |
340 | assert paired_one == false
341 | assert paired_two == false
342 | assert paired_three == false
343 | assert paired_four == false
344 |
345 | assert winner == "01D3CC"
346 | assert scores == %{"EBDA4E" => 1, "01D3CC" => 2}
347 | end
348 |
349 | test "prepare restart does nothing if winner is nil" do
350 | state = %Match.Game{
351 | cards: [
352 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
353 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true, :paired => false},
354 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
355 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false, :paired => false},
356 | ],
357 | winner: nil,
358 | players: [
359 | "EBDA4E",
360 | "01D3CC"
361 | ],
362 | active_player_id: "01D3CC",
363 | scores: %{"EBDA4E" => 1, "01D3CC" => 1}
364 | }
365 |
366 | new_state = Match.Game.prepare_restart(state)
367 |
368 | %Match.Game{cards: cards, winner: winner, scores: scores} = new_state
369 | [
370 | %Match.Card{flipped: flip_one, paired: paired_one},
371 | %Match.Card{flipped: flip_two, paired: paired_two},
372 | %Match.Card{flipped: flip_three, paired: paired_three},
373 | %Match.Card{flipped: flip_four, paired: paired_four},
374 | ] = cards
375 |
376 | assert flip_one == false
377 | assert flip_two == true
378 | assert flip_three == false
379 | assert flip_four == false
380 |
381 | assert paired_one == true
382 | assert paired_two == false
383 | assert paired_three == true
384 | assert paired_four == false
385 |
386 | assert winner == nil
387 | assert scores == %{"EBDA4E" => 1, "01D3CC" => 1}
388 | end
389 |
390 | test "flipping will append score when user id already in the scores map" do
391 | state = %Match.Game{
392 | cards: [
393 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
394 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true, :paired => false},
395 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
396 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false, :paired => false},
397 | ],
398 | winner: nil,
399 | players: [
400 | "EBDA4E",
401 | "01D3CC"
402 | ],
403 | active_player_id: "01D3CC",
404 | scores: %{"01D3CC" => 1}
405 | }
406 |
407 | new_state = Match.Game.flip(state, "3079822", "01D3CC")
408 |
409 | %Match.Game{winner: winner, scores: scores} = new_state
410 |
411 | assert winner == "01D3CC"
412 | assert scores == %{"01D3CC" => 2}
413 | end
414 |
415 | test "flipping when animating is marked as true flip does nothing" do
416 | state = %Match.Game{
417 | cards: [
418 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => false},
419 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true, :paired => false},
420 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => true, :paired => false},
421 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false, :paired => false},
422 | ],
423 | winner: nil,
424 | animating: true
425 | }
426 |
427 | new_state = Match.Game.flip(state, "3079822", "01D3CC")
428 |
429 | %Match.Game{cards: cards, winner: winner, animating: animating} = new_state
430 | [
431 | %Match.Card{flipped: flip_one, paired: paired_one},
432 | %Match.Card{flipped: flip_two, paired: paired_two},
433 | %Match.Card{flipped: flip_three, paired: paired_three},
434 | %Match.Card{flipped: flip_four, paired: paired_four},
435 | ] = cards
436 |
437 | assert flip_one == false
438 | assert flip_two == true
439 | assert flip_three == true
440 | assert flip_four == false
441 |
442 | assert paired_one == false
443 | assert paired_two == false
444 | assert paired_three == false
445 | assert paired_four == false
446 |
447 | assert winner == nil
448 | assert animating == true
449 | end
450 |
451 | test "flipping when winner is marked as true flip does nothing" do
452 | state = %Match.Game{
453 | cards: [
454 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
455 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => false, :paired => true},
456 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false, :paired => true},
457 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false, :paired => true},
458 | ],
459 | winner: true,
460 | animating: false
461 | }
462 |
463 | new_state = Match.Game.flip(state, "3079822", "01D3CC")
464 |
465 | %Match.Game{cards: cards, winner: winner, animating: animating} = new_state
466 | [
467 | %Match.Card{flipped: flip_one, paired: paired_one},
468 | %Match.Card{flipped: flip_two, paired: paired_two},
469 | %Match.Card{flipped: flip_three, paired: paired_three},
470 | %Match.Card{flipped: flip_four, paired: paired_four},
471 | ] = cards
472 |
473 | assert flip_one == false
474 | assert flip_two == false
475 | assert flip_three == false
476 | assert flip_four == false
477 |
478 | assert paired_one == true
479 | assert paired_two == true
480 | assert paired_three == true
481 | assert paired_four == true
482 |
483 | assert winner == true
484 | assert animating == false
485 | end
486 |
487 | test "join will add player_id to players list and leave will remove player_id from players list" do
488 | state = %Match.Game{
489 | cards: [
490 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false},
491 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => false},
492 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
493 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
494 | ]
495 | }
496 |
497 | {:ok, new_state} = Match.Game.join(state, "01D3CC")
498 |
499 | %Match.Game{active_player_id: active_player_id, players: players} = new_state
500 | [ player ] = players
501 |
502 | assert Enum.count(players) == 1
503 | assert active_player_id == "01D3CC"
504 | assert player == "01D3CC"
505 |
506 | leave_state = Match.Game.leave(new_state, "01D3CC")
507 |
508 | %Match.Game{active_player_id: active_player_id, players: players} = leave_state
509 |
510 | assert Enum.count(players) == 0
511 | assert active_player_id == nil
512 |
513 | {:ok, joined_again} = Match.Game.join(leave_state, "01D3CC")
514 |
515 | %Match.Game{active_player_id: active_player_id, players: players} = joined_again
516 | [ player ] = players
517 |
518 | assert Enum.count(players) == 1
519 | assert active_player_id == "01D3CC"
520 | assert player == "01D3CC"
521 |
522 | {:ok, another_join} = Match.Game.join(joined_again, "EBDA4E")
523 |
524 | %Match.Game{active_player_id: active_player_id, players: players} = another_join
525 | [ player_one, player_two ] = players
526 |
527 | assert Enum.count(players) == 2
528 | assert active_player_id == "01D3CC"
529 | assert player_one == "EBDA4E"
530 | assert player_two == "01D3CC"
531 |
532 | {:error, message} = Match.Game.join(another_join, "01D3CC")
533 | assert message == "join failed: game was full"
534 |
535 | {:error, message} = Match.Game.join(another_join, "EBDA4E")
536 | assert message == "join failed: game was full"
537 |
538 | leave_again_state = Match.Game.leave(another_join, "01D3CC")
539 |
540 | %Match.Game{active_player_id: active_player_id, players: players} = leave_again_state
541 | [ player ] = players
542 |
543 | assert Enum.count(players) == 1
544 | assert active_player_id == "EBDA4E"
545 | assert player == "EBDA4E"
546 |
547 | leave_duplicate = Match.Game.leave(leave_again_state, "01D3CC")
548 |
549 | %Match.Game{active_player_id: active_player_id, players: players} = leave_duplicate
550 | [ player ] = players
551 |
552 | assert Enum.count(players) == 1
553 | assert active_player_id == "EBDA4E"
554 | assert player == "EBDA4E"
555 | end
556 |
557 | test "flipping the 2nd card in a match will NOT mark the cards as flipped when player_id is not active" do
558 | state = %Match.Game{
559 | cards: [
560 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => false},
561 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true},
562 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
563 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
564 | ],
565 | winner: nil,
566 | players: [
567 | "EBDA4E",
568 | "01D3CC"
569 | ],
570 | active_player_id: "EBDA4E"
571 | }
572 |
573 | new_state = Match.Game.flip(state, "3079822", "01D3CC")
574 |
575 | %Match.Game{cards: cards, winner: winner} = new_state
576 | [
577 | %Match.Card{flipped: flip_one},
578 | %Match.Card{flipped: flip_two},
579 | %Match.Card{flipped: flip_three},
580 | %Match.Card{flipped: flip_four},
581 | ] = cards
582 |
583 | assert flip_one == false
584 | assert flip_two == true
585 | assert flip_three == false
586 | assert flip_four == false
587 |
588 | assert winner == nil
589 | end
590 |
591 | test "unflip will not explode with only 1 active player" do
592 | state = %Match.Game{
593 | cards: [
594 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => true},
595 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true},
596 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
597 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
598 | ],
599 | winner: nil,
600 | animating: true,
601 | players: [
602 | "01D3CC"
603 | ],
604 | active_player_id: "01D3CC"
605 | }
606 |
607 | new_state = Match.Game.unflip(state)
608 | %Match.Game{players: players, active_player_id: active_player_id} = new_state
609 |
610 | [player] = players
611 |
612 | assert player == "01D3CC"
613 | assert active_player_id == "01D3CC"
614 | end
615 |
616 | test "flip and unflip will rotate between players correctly" do
617 | state = %Match.Game{
618 | cards: [
619 | %Match.Card{:id => "24CEDF1", :name => "one", :image => "/images/cards/one.png", :flipped => true},
620 | %Match.Card{:id => "3079821", :name => "two", :image => "/images/cards/two.png", :flipped => true},
621 | %Match.Card{:id => "24CEDF2", :name => "one", :image => "/images/cards/one.png", :flipped => false},
622 | %Match.Card{:id => "3079822", :name => "two", :image => "/images/cards/two.png", :flipped => false},
623 | ],
624 | winner: nil,
625 | animating: true,
626 | players: [
627 | "01D3CC",
628 | "EBDA4E",
629 | "ADDE47"
630 | ],
631 | active_player_id: "01D3CC"
632 | }
633 |
634 | state_two = Match.Game.unflip(state)
635 | %Match.Game{active_player_id: active_player_id} = state_two
636 |
637 | assert active_player_id == "EBDA4E"
638 |
639 | state_three = Match.Game.flip(state_two, "3079821", "EBDA4E")
640 | state_four = Match.Game.flip(state_three, "24CEDF1", "EBDA4E")
641 |
642 | state_five = Match.Game.unflip(state_four)
643 | %Match.Game{active_player_id: active_player_id} = state_five
644 |
645 | assert active_player_id == "ADDE47"
646 | end
647 | end
648 |
--------------------------------------------------------------------------------
/app/test/match/hash_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.HashTest do
2 | use ExUnit.Case, async: true
3 |
4 | alias Match.Hash
5 |
6 | @user_one "A4E3400CF711E76BBD86C57CA"
7 | @user_two "EBDA4E3FDECD8F2759D96250A"
8 |
9 | test "hmac will generate the same value for key consistently" do
10 | one = Hash.hmac("type:user", "toran")
11 | assert one == @user_one
12 |
13 | two = Hash.hmac("type:user", "toran")
14 | assert two == @user_one
15 |
16 | unknown = Hash.hmac("type:unknown", "toran")
17 | assert unknown != @user_one
18 |
19 | joel = Hash.hmac("type:user", "joel")
20 | assert joel == @user_two
21 | end
22 |
23 | test "hmac will generate hash with specified length" do
24 | bird = Hash.hmac("type:card", "bird", 6)
25 | assert bird == "6F0108"
26 | bird_again = Hash.hmac("type:card", "bird", 6)
27 | assert bird_again == "6F0108"
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/app/test/match/logon_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.LogonTest do
2 | use Match.DataCase, async: false
3 |
4 | alias Match.Logon
5 |
6 | @invite "elixir2019"
7 | @user_one "A4E3400CF711E76BBD86C57CA"
8 | @user_two "EBDA4E3FDECD8F2759D96250A"
9 |
10 | test "get and put work" do
11 | {:ok, _} = GenServer.start_link(Logon, :ok)
12 |
13 | {:ok, result} = Logon.put(:logon, "toran", "abcd1234", @invite)
14 | {id, username, _icon} = result
15 | assert id == @user_one
16 | assert username == "toran"
17 |
18 | {username, _icon} = Logon.get(:logon, @user_one)
19 | assert username === "toran"
20 | assert Logon.get_by_username_and_password(:logon, "toran", "abcd1234") === @user_one
21 | assert Logon.get_by_username_and_password(:logon, "joel", "defg4567") === nil
22 |
23 | {:ok, result} = Logon.put(:logon, "joel", "defg4567", @invite)
24 | {id, username, _icon} = result
25 | assert id == @user_two
26 | assert username == "joel"
27 |
28 | {username, _icon} = Logon.get(:logon, @user_one)
29 | assert username === "toran"
30 | {username, _icon} = Logon.get(:logon, @user_two)
31 | assert username === "joel"
32 |
33 | assert Logon.get_by_username_and_password(:logon, "toran", "abcd1234") === @user_one
34 | assert Logon.get_by_username_and_password(:logon, "joel", "defg4567") === @user_two
35 | assert Logon.get_by_username_and_password(:logon, "joel", "def4577") === nil
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/app/test/match/statistics_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.StatisticsTest do
2 | use Match.DataCase, async: true
3 |
4 | alias Match.Repo
5 | alias Match.Statistic
6 | alias Match.Statistics
7 |
8 | @user_one "A4E3400CF711E76BBD86C57CA"
9 | @user_two "EBDA4E3FDECD8F2759D96250A"
10 | @user_three "D3DFFDC4AFE0172529ED3CFA5"
11 |
12 | @valid_attrs %{user: @user_one, wins: 1, flips: 9}
13 |
14 | test "get_by user will return Statistic or nil" do
15 | result = Statistics.get_by(%{user: @user_one})
16 | assert result == nil
17 |
18 | Statistic
19 | |> struct(@valid_attrs)
20 | |> Repo.insert()
21 |
22 | result = Statistics.get_by(%{user: @user_one})
23 | %Match.Statistic{user: user, wins: wins, flips: flips} = result
24 | assert user == @user_one
25 | assert wins == 1
26 | assert flips == 9
27 | end
28 |
29 | test "all will return Statistics" do
30 | results = Statistics.all()
31 | assert results == []
32 |
33 | Statistic
34 | |> struct(@valid_attrs)
35 | |> Repo.insert()
36 |
37 | Statistic
38 | |> struct(%{user: @user_two, wins: 3, flips: 1})
39 | |> Repo.insert()
40 |
41 | results = Statistics.all()
42 | [ one, two ] = results
43 |
44 | %Match.Statistic{user: user, wins: wins, flips: flips} = one
45 | assert user == @user_one
46 | assert wins == 1
47 | assert flips == 9
48 |
49 | %Match.Statistic{user: user, wins: wins, flips: flips} = two
50 | assert user == @user_two
51 | assert wins == 3
52 | assert flips == 1
53 | end
54 |
55 | test "upsert_by will insert when no data present" do
56 | {:ok, result} = Statistics.upsert_by(@user_one, @valid_attrs)
57 | %Match.Statistic{user: user, wins: wins, flips: flips} = result
58 | assert user == @user_one
59 | assert wins == 1
60 | assert flips == 9
61 | end
62 |
63 | test "upsert_by will update when data present" do
64 | Statistic
65 | |> struct(@valid_attrs)
66 | |> Repo.insert()
67 |
68 | {:ok, result} = Statistics.upsert_by(@user_one, %{user: @user_one, wins: 2, flips: 18})
69 | %Match.Statistic{user: user, wins: wins, flips: flips} = result
70 | assert user == @user_one
71 | assert wins == 2
72 | assert flips == 18
73 | end
74 |
75 | test "parse will return 2 insert friendly maps in a list" do
76 | winner = @user_two
77 | scores = %{@user_one => 1, @user_two => 2}
78 |
79 | results = Statistic.parse(scores, winner)
80 | assert Enum.count(results) == 2
81 | [one, two] = results
82 |
83 | [{user, value}] = Map.to_list(one)
84 | %{wins: wins, flips: flips} = value
85 | assert user == @user_one
86 | assert wins == 0
87 | assert flips == 1
88 |
89 | [{user, value}] = Map.to_list(two)
90 | %{wins: wins, flips: flips} = value
91 | assert user == @user_two
92 | assert wins == 1
93 | assert flips == 2
94 | end
95 |
96 | test "transform_previous will return map with user as key" do
97 | Statistic
98 | |> struct(@valid_attrs)
99 | |> Repo.insert()
100 |
101 | Statistic
102 | |> struct(%{user: @user_two, wins: 3, flips: 1})
103 | |> Repo.insert()
104 |
105 | results = Statistics.all()
106 | [ one, two ] = Statistic.transform_previous(results)
107 |
108 | [{user, value}] = Map.to_list(one)
109 | %{wins: wins, flips: flips} = value
110 | assert user == @user_one
111 | assert wins == 1
112 | assert flips == 9
113 |
114 | [{user, value}] = Map.to_list(two)
115 | %{wins: wins, flips: flips} = value
116 | assert user == @user_two
117 | assert wins == 3
118 | assert flips == 1
119 | end
120 |
121 | test "get_persisted_stats will return Statistic for each in the database" do
122 | statistics = [%{@user_one => %{wins: 1, flips: 9}}, %{@user_three => %{wins: 2, flips: 25}}]
123 |
124 | scores = %{@user_one => 1, @user_two => 2}
125 | results = Statistic.get_persisted_stats(scores, statistics)
126 | assert Enum.count(results) == 1
127 | [ one ] = results
128 |
129 | [{user, value}] = Map.to_list(one)
130 | %{wins: wins, flips: flips} = value
131 | assert user == @user_one
132 | assert wins == 1
133 | assert flips == 9
134 | end
135 |
136 | test "merge_stats will correctly sum previous and new stats" do
137 | statistics = [%{@user_one => %{wins: 1, flips: 9}}, %{@user_two => %{wins: 0, flips: 2}}]
138 |
139 | stat_one = %{@user_two => %{wins: 1, flips: 0}}
140 | stat_two = %{@user_one => %{wins: 0, flips: 3}}
141 | stats = [ stat_one, stat_two ]
142 |
143 | results = Statistic.merge_stats(statistics, stats)
144 |
145 | assert Enum.count(results) == 2
146 |
147 | one = Map.get(results, @user_one)
148 | %{wins: wins, flips: flips} = one
149 | assert wins == 1
150 | assert flips == 12
151 |
152 | two = Map.get(results, @user_two)
153 | %{wins: wins, flips: flips} = two
154 | assert wins == 1
155 | assert flips == 2
156 | end
157 |
158 | test "insert_statistics will merge database with new stats data and insert" do
159 | Statistic
160 | |> struct(@valid_attrs)
161 | |> Repo.insert()
162 |
163 | data = Statistics.all()
164 | statistics = Statistic.transform_previous(data)
165 | winner = @user_two
166 | scores = %{@user_one => 1, @user_two => 2}
167 | results = Statistic.insert_statistics(scores, winner, statistics)
168 |
169 | assert Enum.count(results) == 2
170 | assert results == [
171 | %{@user_one => %{flips: 10, wins: 1}},
172 | %{@user_two => %{flips: 2, wins: 1}}
173 | ]
174 |
175 | inserted_one = Statistics.get_by(%{user: @user_one})
176 | %Match.Statistic{user: user, wins: wins, flips: flips} = inserted_one
177 | assert user == @user_one
178 | assert wins == 1
179 | assert flips == 10
180 |
181 | inserted_two = Statistics.get_by(%{user: @user_two})
182 | %Match.Statistic{user: user, wins: wins, flips: flips} = inserted_two
183 | assert user == @user_two
184 | assert wins == 1
185 | assert flips == 2
186 | end
187 |
188 | test "insert_statistics will properly calc wins and flips for both users" do
189 | Statistic
190 | |> struct(%{user: @user_one, wins: 1, flips: 10})
191 | |> Repo.insert()
192 | Statistic
193 | |> struct(%{user: @user_two, wins: 1, flips: 2})
194 | |> Repo.insert()
195 |
196 | data = Statistics.all()
197 | statistics = Statistic.transform_previous(data)
198 | winner = @user_one
199 | scores = %{@user_one => 2, @user_two => 1}
200 | results = Statistic.insert_statistics(scores, winner, statistics)
201 |
202 | assert Enum.count(results) == 2
203 | assert results == [
204 | %{@user_one => %{flips: 12, wins: 2}},
205 | %{@user_two => %{flips: 3, wins: 1}}
206 | ]
207 |
208 | inserted_one = Statistics.get_by(%{user: @user_one})
209 | %Match.Statistic{user: user, wins: wins, flips: flips} = inserted_one
210 | assert user == @user_one
211 | assert wins == 2
212 | assert flips == 12
213 |
214 | inserted_two = Statistics.get_by(%{user: @user_two})
215 | %Match.Statistic{user: user, wins: wins, flips: flips} = inserted_two
216 | assert user == @user_two
217 | assert wins == 1
218 | assert flips == 3
219 | end
220 |
221 | test "insert_statistics will continue to include previous stats even if user has 0 new flips" do
222 | Statistic
223 | |> struct(%{user: @user_one, wins: 2, flips: 12})
224 | |> Repo.insert()
225 | Statistic
226 | |> struct(%{user: @user_two, wins: 1, flips: 3})
227 | |> Repo.insert()
228 |
229 | data = Statistics.all()
230 | statistics = Statistic.transform_previous(data)
231 | winner = @user_one
232 | scores = %{@user_one => 3}
233 | results = Statistic.insert_statistics(scores, winner, statistics)
234 |
235 | assert Enum.count(results) == 2
236 | assert results == [
237 | %{@user_one => %{flips: 15, wins: 3}},
238 | %{@user_two => %{flips: 3, wins: 1}}
239 | ]
240 |
241 | inserted_one = Statistics.get_by(%{user: @user_one})
242 | %Match.Statistic{user: user, wins: wins, flips: flips} = inserted_one
243 | assert user == @user_one
244 | assert wins == 3
245 | assert flips == 15
246 |
247 | inserted_two = Statistics.get_by(%{user: @user_two})
248 | %Match.Statistic{user: user, wins: wins, flips: flips} = inserted_two
249 | assert user == @user_two
250 | assert wins == 1
251 | assert flips == 3
252 | end
253 |
254 | test "insert_statistics will not calc wins 0 during merge for existing stats that do not win" do
255 | Statistic
256 | |> struct(%{user: @user_one, wins: 3, flips: 15})
257 | |> Repo.insert()
258 | Statistic
259 | |> struct(%{user: @user_two, wins: 1, flips: 3})
260 | |> Repo.insert()
261 |
262 | data = Statistics.all()
263 | statistics = Statistic.transform_previous(data)
264 | winner = @user_one
265 | scores = %{@user_one => 2, @user_two => 1}
266 | results = Statistic.insert_statistics(scores, winner, statistics)
267 |
268 | assert Enum.count(results) == 2
269 | assert results == [
270 | %{@user_one => %{flips: 17, wins: 4}},
271 | %{@user_two => %{flips: 4, wins: 1}}
272 | ]
273 |
274 | inserted_one = Statistics.get_by(%{user: @user_one})
275 | %Match.Statistic{user: user, wins: wins, flips: flips} = inserted_one
276 | assert user == @user_one
277 | assert wins == 4
278 | assert flips == 17
279 |
280 | inserted_two = Statistics.get_by(%{user: @user_two})
281 | %Match.Statistic{user: user, wins: wins, flips: flips} = inserted_two
282 | assert user == @user_two
283 | assert wins == 1
284 | assert flips == 4
285 | end
286 |
287 | end
288 |
--------------------------------------------------------------------------------
/app/test/match/users_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Match.UsersTest do
2 | use Match.DataCase, async: true
3 |
4 | alias Match.Repo
5 | alias Match.User
6 |
7 | @id "A4E3400CF711E76BBD86C57CA"
8 | @valid_attrs %{id: @id, username: "toran", password: "abcd1234", invite: "elixir2019", icon: "one"}
9 |
10 | test "changeset is invalid if invite is wrong" do
11 | attrs = @valid_attrs |> Map.put(:invite, "foo")
12 | changeset = User.changeset(%User{}, attrs)
13 | refute changeset.valid?
14 | assert Map.get(changeset, :errors) == [invite: {"invalid invite code", []}]
15 | end
16 |
17 | test "changeset is fine with correct invite code" do
18 | attrs = @valid_attrs |> Map.put(:invite, "elixir2019")
19 | changeset = User.changeset(%User{}, attrs)
20 | assert changeset.valid?
21 | assert Map.get(changeset, :errors) == []
22 | end
23 |
24 | test "changeset is invalid if username is too short" do
25 | attrs = @valid_attrs |> Map.put(:username, "abc")
26 | changeset = User.changeset(%User{}, attrs)
27 | refute changeset.valid?
28 | assert Map.get(changeset, :errors) == [username: {"username must be 4-12 characters", [count: 4, validation: :length, kind: :min, type: :string]}]
29 | end
30 |
31 | test "changeset is invalid if username is too long" do
32 | attrs = @valid_attrs |> Map.put(:username, "abcdefghijklm")
33 | changeset = User.changeset(%User{}, attrs)
34 | refute changeset.valid?
35 | assert Map.get(changeset, :errors) == [username: {"username must be 4-12 characters", [count: 12, validation: :length, kind: :max, type: :string]}]
36 | end
37 |
38 | test "changeset is fine with 4 char username" do
39 | attrs = @valid_attrs |> Map.put(:username, "abcd")
40 | changeset = User.changeset(%User{}, attrs)
41 | assert changeset.valid?
42 | assert Map.get(changeset, :errors) == []
43 | end
44 |
45 | test "changeset is fine with 12 char username" do
46 | attrs = @valid_attrs |> Map.put(:username, "abcdefghijkl")
47 | changeset = User.changeset(%User{}, attrs)
48 | assert changeset.valid?
49 | assert Map.get(changeset, :errors) == []
50 | end
51 |
52 | test "changeset is invalid if password is too short" do
53 | attrs = @valid_attrs |> Map.put(:password, "abcdefg")
54 | changeset = User.changeset(%User{}, attrs)
55 | refute changeset.valid?
56 | assert Map.get(changeset, :errors) == [password: {"password must be 8-20 characters", [count: 8, validation: :length, kind: :min, type: :string]}]
57 | end
58 |
59 | test "changeset is invalid if password is too long" do
60 | attrs = @valid_attrs |> Map.put(:password, "abcdefghijklmnopqrstu")
61 | changeset = User.changeset(%User{}, attrs)
62 | refute changeset.valid?
63 | assert Map.get(changeset, :errors) == [password: {"password must be 8-20 characters", [count: 20, validation: :length, kind: :max, type: :string]}]
64 | end
65 |
66 | test "changeset is fine with 20 char password" do
67 | attrs = @valid_attrs |> Map.put(:password, "abcdefghijklmnopqrst")
68 | changeset = User.changeset(%User{}, attrs)
69 | assert changeset.valid?
70 | assert Map.get(changeset, :errors) == []
71 | end
72 |
73 | test "changeset is fine with 8 char password" do
74 | attrs = @valid_attrs |> Map.put(:password, "abcdefgh")
75 | changeset = User.changeset(%User{}, attrs)
76 | assert changeset.valid?
77 | assert Map.get(changeset, :errors) == []
78 | end
79 |
80 | test "changeset is invalid if username is used already" do
81 | %User{}
82 | |> User.changeset(@valid_attrs)
83 | |> Repo.insert
84 |
85 | duplicate =
86 | %User{}
87 | |> User.changeset(@valid_attrs)
88 | assert {:error, changeset} = Repo.insert(duplicate)
89 | assert Map.get(changeset, :errors) == [id: {"username already exists", [constraint: :unique, constraint_name: "users_pkey"]}]
90 | end
91 | end
92 |
--------------------------------------------------------------------------------
/app/test/match_web/authenticator_test.exs:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.AuthenticatorTest do
2 | use MatchWeb.ConnCase, async: false
3 |
4 | test "login will authenticate the user and redirect unauthenticated requests", %{conn: conn} do
5 | name = "toran"
6 | password = "abcd1234"
7 | login = %{username: name, password: password}
8 | data = %{username: name, invite: "elixir2019", password: password}
9 |
10 | request = get(conn, Routes.page_path(conn, :new, %{visibility: "public"}))
11 | assert String.match?(html_response(request, 302), ~r/.*You are being \
30 | Process.exit(pid, :kill)
31 | purge(Match.Repo)
32 | purge(Match.Game)
33 | purge(Match.Process)
34 | end
35 |
36 | %{game_name: game_name}
37 | end
38 |
39 | test "each card will be rendered with correct click handler, value and background image", %{game_name: game_name} do
40 | {:ok, _} = Match.Session.join(game_name, @user_one.id)
41 | {:ok, _view, html_one} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_one, game_name))
42 |
43 | cards = Floki.find(html_one, ".card")
44 | assert Enum.count(cards) == 4
45 |
46 | assert ["card", "card", "card", "card"] == card_classes(cards)
47 | assert [@id_one_a, @id_one_b, @id_two_a, @id_two_b] == click_values(cards)
48 | assert ["flip", "flip", "flip", "flip"] == click_handlers(cards)
49 | assert ["background-image: url(#{@one})", "background-image: url(#{@one})", "background-image: url(#{@two})", "background-image: url(#{@two})"] == child_styles(cards)
50 | end
51 |
52 | test "flipping 2 incorrect matches will unflip after a brief pause in both clients", %{game_name: game_name} do
53 | {:ok, _} = Match.Session.join(game_name, @user_one.id)
54 | {:ok, view_one, html_one} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_one, game_name))
55 |
56 | {:ok, _} = Match.Session.join(game_name, @user_two.id)
57 | {:ok, view_two, html_two} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_two, game_name))
58 |
59 | click_thru_joined_modal(view_one, view_two)
60 |
61 | cards = Floki.find(html_one, ".card")
62 | assert ["card", "card", "card", "card"] == card_classes(cards)
63 |
64 | cards = Floki.find(html_two, ".card")
65 | assert ["card", "card", "card", "card"] == card_classes(cards)
66 |
67 | html_one = LiveViewTest.render_click(view_one, :flip, @id_two_a)
68 | cards = Floki.find(html_one, ".card")
69 | assert ["card", "card", "card flipped", "card"] == card_classes(cards)
70 |
71 | html_two = LiveViewTest.render(view_two)
72 | cards = Floki.find(html_two, ".card")
73 | assert ["card", "card", "card flipped", "card"] == card_classes(cards)
74 |
75 | html_one = LiveViewTest.render_click(view_one, :flip, @id_one_b)
76 | cards = Floki.find(html_one, ".card")
77 | assert ["card", "card flipped", "card flipped", "card"] == card_classes(cards)
78 |
79 | html_two = LiveViewTest.render(view_two)
80 | cards = Floki.find(html_two, ".card")
81 | assert ["card", "card flipped", "card flipped", "card"] == card_classes(cards)
82 |
83 | Process.sleep(20)
84 |
85 | html_one = LiveViewTest.render(view_one)
86 | cards = Floki.find(html_one, ".card")
87 | assert ["card", "card", "card", "card"] == card_classes(cards)
88 |
89 | html_two = LiveViewTest.render(view_two)
90 | cards = Floki.find(html_two, ".card")
91 | assert ["card", "card", "card", "card"] == card_classes(cards)
92 | end
93 |
94 | test "flipping 2 correct matches will mark a pair in both clients", %{game_name: game_name} do
95 | {:ok, _} = Match.Session.join(game_name, @user_one.id)
96 | {:ok, view_one, html_one} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_one, game_name))
97 |
98 | {:ok, _} = Match.Session.join(game_name, @user_two.id)
99 | {:ok, view_two, html_two} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_two, game_name))
100 |
101 | click_thru_joined_modal(view_one, view_two)
102 |
103 | cards = Floki.find(html_one, ".card")
104 | assert ["card", "card", "card", "card"] == card_classes(cards)
105 |
106 | cards = Floki.find(html_two, ".card")
107 | assert ["card", "card", "card", "card"] == card_classes(cards)
108 |
109 | html_one = LiveViewTest.render_click(view_one, :flip, @id_two_a)
110 | cards = Floki.find(html_one, ".card")
111 | assert ["card", "card", "card flipped", "card"] == card_classes(cards)
112 |
113 | html_two = LiveViewTest.render(view_two)
114 | cards = Floki.find(html_two, ".card")
115 | assert ["card", "card", "card flipped", "card"] == card_classes(cards)
116 |
117 | html_one = LiveViewTest.render_click(view_one, :flip, @id_two_b)
118 | cards = Floki.find(html_one, ".card")
119 | assert ["card", "card", "card found", "card found"] == card_classes(cards)
120 |
121 | html_two = LiveViewTest.render(view_two)
122 | cards = Floki.find(html_two, ".card")
123 | assert ["card", "card", "card found", "card found"] == card_classes(cards)
124 | end
125 |
126 | test "players rotate between turns in both clients and winner shown in modal", %{game_name: game_name} do
127 | {:ok, _} = Match.Session.join(game_name, @user_one.id)
128 | {:ok, view_one, html_one} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_one, game_name))
129 |
130 | {:ok, _} = Match.Session.join(game_name, @user_two.id)
131 | {:ok, view_two, html_two} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_two, game_name))
132 |
133 | click_thru_joined_modal(view_one, view_two)
134 |
135 | {player, score} = active_player_score(html_one)
136 | assert player == @toran
137 | assert score == "0"
138 |
139 | {player, score} = active_player_score(html_two)
140 | assert player == @toran
141 | assert score == "0"
142 |
143 | LiveViewTest.render_click(view_one, :flip, @id_two_a)
144 | LiveViewTest.render_click(view_one, :flip, @id_one_b)
145 |
146 | Process.sleep(20)
147 |
148 | html_one = LiveViewTest.render(view_one)
149 | {player, score} = active_player_score(html_one)
150 | assert player == @brandon
151 | assert score == "0"
152 |
153 | html_two = LiveViewTest.render(view_two)
154 | {player, score} = active_player_score(html_two)
155 | assert player == @brandon
156 | assert score == "0"
157 |
158 | LiveViewTest.render_click(view_two, :flip, @id_one_a)
159 | LiveViewTest.render_click(view_two, :flip, @id_one_b)
160 |
161 | html_two = LiveViewTest.render(view_two)
162 | {player, score} = active_player_score(html_two)
163 | assert player == @brandon
164 | assert score == "1"
165 |
166 | html_one = LiveViewTest.render(view_one)
167 | {player, score} = active_player_score(html_one)
168 | assert player == @brandon
169 | assert score == "1"
170 |
171 | LiveViewTest.render_click(view_two, :flip, @id_two_a)
172 | LiveViewTest.render_click(view_two, :flip, @id_two_b)
173 |
174 | html_two = LiveViewTest.render(view_two)
175 | {player, score} = active_player_score(html_two)
176 | assert player == @brandon
177 | assert score == "2"
178 |
179 | html_one = LiveViewTest.render(view_one)
180 | {player, score} = active_player_score(html_one)
181 | assert player == @brandon
182 | assert score == "2"
183 |
184 | assert Enum.count(modal(html_one)) == 1
185 | assert Enum.count(modal(html_two)) == 1
186 | assert winner(html_one) == "#{@brandon} won!"
187 | assert winner(html_two) == "#{@brandon} won!"
188 |
189 | LiveViewTest.render_click(view_two, :prepare_restart, "")
190 | Process.sleep(2)
191 |
192 | html_one = LiveViewTest.render(view_one)
193 | assert Enum.count(modal(html_one)) == 0
194 | html_two = LiveViewTest.render(view_two)
195 | assert Enum.count(modal(html_two)) == 0
196 |
197 | cards = Floki.find(html_one, ".card")
198 | assert ["card", "card", "card", "card"] == card_classes(cards)
199 | cards = Floki.find(html_two, ".card")
200 | assert ["card", "card", "card", "card"] == card_classes(cards)
201 |
202 | {player, score} = active_player_score(html_one)
203 | assert player == @brandon
204 | assert score == "0"
205 |
206 | {player, score} = active_player_score(html_two)
207 | assert player == @brandon
208 | assert score == "0"
209 | end
210 |
211 | test "error modal shows up when backing session killed", %{game_name: game_name} do
212 | {:ok, _} = Match.Session.join(game_name, @user_one.id)
213 | {:ok, view_one, _html_one} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_one, game_name))
214 |
215 | {:ok, _} = Match.Session.join(game_name, @user_two.id)
216 | {:ok, view_two, _html_two} = LiveViewTest.mount(Endpoint, GameLive, session: session(@user_two, game_name))
217 |
218 | click_thru_joined_modal(view_one, view_two)
219 |
220 | pid = Match.Session.session_pid(game_name)
221 | Process.exit(pid, :shutdown)
222 |
223 | html_one = LiveViewTest.render(view_one)
224 | assert Enum.count(modal(html_one)) == 0
225 | html_two = LiveViewTest.render(view_two)
226 | assert Enum.count(modal(html_two)) == 0
227 |
228 | LiveViewTest.render_click(view_one, :flip, @id_two_a)
229 |
230 | html_one = LiveViewTest.render(view_one)
231 | assert Enum.count(modal(html_one)) == 1
232 | assert error(html_one) == "an error occurred"
233 |
234 | html_two = LiveViewTest.render(view_two)
235 | assert Enum.count(modal(html_two)) == 0
236 | end
237 |
238 | defp modal(html) do
239 | Floki.find(html, ".splash")
240 | end
241 |
242 | defp winner(html) do
243 | Floki.find(html, ".content h1") |> Floki.text
244 | end
245 |
246 | defp joined(html) do
247 | Floki.find(html, ".content h1") |> Floki.text
248 | end
249 |
250 | defp error(html) do
251 | Floki.find(html, ".content h1") |> Floki.text
252 | end
253 |
254 | defp click_thru_joined_modal(view_one, view_two) do
255 | html_one = LiveViewTest.render(view_one)
256 | html_two = LiveViewTest.render(view_two)
257 |
258 | assert Enum.count(modal(html_one)) == 1
259 | assert Enum.count(modal(html_two)) == 0
260 |
261 | assert joined(html_one) == "brandon joined!"
262 |
263 | LiveViewTest.render_click(view_one, :continue, "")
264 |
265 | html_one = LiveViewTest.render(view_one)
266 | html_two = LiveViewTest.render(view_two)
267 |
268 | assert Enum.count(modal(html_one)) == 0
269 | assert Enum.count(modal(html_two)) == 0
270 | end
271 |
272 | defp card_classes(cards) do
273 | cards
274 | |> Floki.attribute("class")
275 | |> Enum.map(&(String.trim(&1)))
276 | end
277 |
278 | defp click_handlers(cards) do
279 | cards
280 | |> Floki.attribute("phx-click")
281 | end
282 |
283 | defp click_values(cards) do
284 | cards
285 | |> Floki.attribute("phx-value")
286 | end
287 |
288 | defp child_styles(cards) do
289 | cards
290 | |> Enum.map(fn({_tag, _attr, child}) ->
291 | [_, front] = child
292 | [attribute] = Floki.attribute(front, "style")
293 | attribute
294 | end)
295 | end
296 |
297 | defp active_player_score(html) do
298 | player = Floki.find(html, ".active-player") |> Floki.text
299 | score = Floki.find(html, ".active-player-score") |> Floki.text
300 | {player, score}
301 | end
302 |
303 | defp session(current_user, game_name) do
304 | %{:id => id, :username => username} = current_user
305 | %{
306 | game_name: game_name,
307 | player_id: id,
308 | username: username,
309 | joined_id: nil,
310 | error: nil
311 | }
312 | end
313 |
314 | defp patch_random do
315 | Code.eval_string """
316 | defmodule Match.Random do
317 | def take_random(cards, number) do
318 | Enum.take(cards, number)
319 | end
320 | end
321 | """
322 | end
323 |
324 | defp patch_process do
325 | Code.eval_string """
326 | defmodule Match.Process do
327 | def sleep(t) do
328 | Process.sleep(t)
329 | end
330 | end
331 | """
332 | end
333 |
334 | defp patch_repo do
335 | Code.eval_string """
336 | defmodule Match.Repo do
337 | def all(_), do: nil
338 | def get_by(_, _), do: nil
339 | def get_by(_, _, _), do: nil
340 | def insert_or_update(_), do: nil
341 | end
342 | """
343 | end
344 |
345 | defp purge(module) do
346 | :code.purge(module)
347 | :code.delete(module)
348 | end
349 | end
350 |
--------------------------------------------------------------------------------
/app/test/match_web/views/error_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.ErrorViewTest do
2 | use MatchWeb.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(MatchWeb.ErrorView, "404.html", []) == "Not Found"
9 | end
10 |
11 | test "renders 500.html" do
12 | assert render_to_string(MatchWeb.ErrorView, "500.html", []) == "Internal Server Error"
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/app/test/match_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.LayoutViewTest do
2 | use MatchWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/app/test/match_web/views/page_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.PageViewTest do
2 | use MatchWeb.ConnCase, async: true
3 | end
4 |
--------------------------------------------------------------------------------
/app/test/support/channel_case.ex:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.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 | it cannot be async. For this reason, every test runs
12 | inside a transaction which is reset at the beginning
13 | of the test unless the test case is marked as async.
14 | """
15 |
16 | use ExUnit.CaseTemplate
17 |
18 | using do
19 | quote do
20 | # Import conveniences for testing with channels
21 | use Phoenix.ChannelTest
22 |
23 | # The default endpoint for testing
24 | @endpoint MatchWeb.Endpoint
25 | end
26 | end
27 |
28 | setup tags do
29 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(Match.Repo)
30 |
31 | unless tags[:async] do
32 | Ecto.Adapters.SQL.Sandbox.mode(Match.Repo, {:shared, self()})
33 | end
34 |
35 | :ok
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/app/test/support/conn_case.ex:
--------------------------------------------------------------------------------
1 | defmodule MatchWeb.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 | it cannot be async. For this reason, every test runs
12 | inside a transaction which is reset at the beginning
13 | of the test unless the test case is marked as async.
14 | """
15 |
16 | use ExUnit.CaseTemplate
17 |
18 | using do
19 | quote do
20 | # Import conveniences for testing with connections
21 | use Phoenix.ConnTest
22 | alias MatchWeb.Router.Helpers, as: Routes
23 |
24 | # The default endpoint for testing
25 | @endpoint MatchWeb.Endpoint
26 | end
27 | end
28 |
29 | setup tags do
30 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(Match.Repo)
31 |
32 | unless tags[:async] do
33 | Ecto.Adapters.SQL.Sandbox.mode(Match.Repo, {:shared, self()})
34 | end
35 |
36 | {:ok, conn: Phoenix.ConnTest.build_conn()}
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/app/test/support/data_case.ex:
--------------------------------------------------------------------------------
1 | defmodule Match.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 | it cannot be async. For this reason, every test runs
11 | inside a transaction which is reset at the beginning
12 | of the test unless the test case is marked as async.
13 | """
14 |
15 | use ExUnit.CaseTemplate
16 |
17 | using do
18 | quote do
19 | alias Match.Repo
20 |
21 | import Ecto
22 | import Ecto.Changeset
23 | import Ecto.Query
24 | import Match.DataCase
25 | end
26 | end
27 |
28 | setup tags do
29 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(Match.Repo)
30 |
31 | unless tags[:async] do
32 | Ecto.Adapters.SQL.Sandbox.mode(Match.Repo, {:shared, self()})
33 | end
34 |
35 | :ok
36 | end
37 |
38 | @doc """
39 | A helper that transforms changeset errors into a map of messages.
40 |
41 | assert {:error, changeset} = Accounts.create_user(%{password: "short"})
42 | assert "password is too short" in errors_on(changeset).password
43 | assert %{password: ["password is too short"]} = errors_on(changeset)
44 |
45 | """
46 | def errors_on(changeset) do
47 | Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
48 | Enum.reduce(opts, message, fn {key, value}, acc ->
49 | String.replace(acc, "%{#{key}}", to_string(value))
50 | end)
51 | end)
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/app/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 | Ecto.Adapters.SQL.Sandbox.mode(Match.Repo, :manual)
3 |
--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: '2.2'
2 |
3 | services:
4 | app:
5 | build:
6 | context: ./app
7 | dockerfile: Dockerfile
8 | depends_on:
9 | postgres:
10 | condition: service_healthy
11 | env_file:
12 | - .env
13 | ports:
14 | - 4000
15 | entrypoint: ./entrypoint.sh
16 |
17 | postgres:
18 | image: postgres:11.1-alpine
19 | volumes:
20 | - "./volumes/postgres:/var/lib/postgresql/data"
21 | ports:
22 | - 5432:5432
23 | healthcheck:
24 | test: ["CMD-SHELL", "pg_isready -U postgres"]
25 | interval: 10s
26 | timeout: 5s
27 | retries: 5
28 |
29 | proxy:
30 | build:
31 | context: ./nginx
32 | dockerfile: Dockerfile
33 | ports:
34 | - 80:80
35 | links:
36 | - app
37 |
--------------------------------------------------------------------------------
/nginx/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM nginx
2 |
3 | COPY nginx.conf /etc/nginx/nginx.conf
4 |
--------------------------------------------------------------------------------
/nginx/nginx.conf:
--------------------------------------------------------------------------------
1 | worker_processes 4;
2 |
3 | events { worker_connections 1024; }
4 |
5 | http {
6 | sendfile on;
7 |
8 | upstream app_servers {
9 | server example_app_1:4000;
10 | }
11 |
12 | server {
13 | listen 80;
14 |
15 | location / {
16 | proxy_pass http://app_servers;
17 | proxy_redirect off;
18 | proxy_set_header Host $host;
19 | proxy_set_header X-Real-IP $remote_addr;
20 | proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
21 | proxy_set_header X-Forwarded-Host $server_name;
22 | proxy_http_version 1.1;
23 | proxy_set_header Upgrade $http_upgrade;
24 | proxy_set_header Connection "Upgrade";
25 | }
26 | }
27 | }
28 |
--------------------------------------------------------------------------------