From 90c3b06cfc5095ff63cd1a12036f0407d3d540e8 Mon Sep 17 00:00:00 2001 From: Ryan Pandya Date: Thu, 3 Nov 2022 18:19:17 -0400 Subject: [PATCH] Start relationship tests; create events --- friends/lib/friends/event.ex | 56 +++++++++++++++++ friends/lib/friends/friend.ex | 2 +- friends/lib/friends/relationship.ex | 17 ++++- .../{friend_test.exs => friends_test.exs} | 30 +++++---- friends/test/friends/relationships_test.exs | 63 +++++++++++++++++++ .../controllers/friend_controller_test.exs | 7 +-- 6 files changed, 155 insertions(+), 20 deletions(-) create mode 100644 friends/lib/friends/event.ex rename friends/test/friends/{friend_test.exs => friends_test.exs} (77%) create mode 100644 friends/test/friends/relationships_test.exs diff --git a/friends/lib/friends/event.ex b/friends/lib/friends/event.ex new file mode 100644 index 0000000..e48f7bb --- /dev/null +++ b/friends/lib/friends/event.ex @@ -0,0 +1,56 @@ +defmodule Friends.Event do + use Ecto.Schema + alias Friends.{Relationship,Event} + alias Places.Place + + @repo Friends.Repo + + schema "events" do + field(:date, :date) + field(:name, :string) + field(:story, :string) + field(:defining, :boolean) + field(:solo, :boolean) + + belongs_to(:place, Place) + belongs_to(:relationship, Relationship) + end + + def meet(friend1, friend2, opts \\ nil) do + relationship = Relationship.get_or_new(friend1, friend2) + opts = opts ++ [if opts[:place] do + { + :place_id, + Places.Place.get_or_new(opts[:place]).id + } + end] + {:ok, event} = %Event{ + story: opts[:story], + date: opts[:date], + place_id: opts[:place_id], + relationship_id: relationship.id + } |> @repo.insert + event + end + + def people(event) do + event.relationship |> Relationship.members + end + + def age(event) do + years = Date.diff(Date.utc_today, event.date) + |> div(365) + if years == 0 do + months = Date.diff(Date.utc_today, event.date) + |> rem(365) |> div(12) + {months, :month} + else + {years, :year} + end + end + + def print_age(age) do + Friends.Helpers.pluralize(age |> elem(0), age |> elem(1)) + end + +end diff --git a/friends/lib/friends/friend.ex b/friends/lib/friends/friend.ex index 6cd7f64..3183e1f 100644 --- a/friends/lib/friends/friend.ex +++ b/friends/lib/friends/friend.ex @@ -104,7 +104,7 @@ defmodule Friends.Friend do changeset |> generate_slug |> @repo.insert! - |> load_user + |> load_preloads end diff --git a/friends/lib/friends/relationship.ex b/friends/lib/friends/relationship.ex index 58f1f16..11b013f 100644 --- a/friends/lib/friends/relationship.ex +++ b/friends/lib/friends/relationship.ex @@ -1,7 +1,7 @@ defmodule Friends.Relationship do use Ecto.Schema import Ecto.Query - alias Friends.{Relationship,Event,Friend} + alias Friends.{Relationship,Friend} @repo Friends.Repo @@ -74,7 +74,7 @@ defmodule Friends.Relationship do @repo.all(from(r in Friends.Relationship, preload: ^preloads)) end - def new(friend1, friend2, type \\ 0) do + def new(friend1, friend2, type \\ 2) do id1 = friend1.id id2 = friend2.id {:ok, relationship} = @repo.insert( @@ -136,4 +136,17 @@ defmodule Friends.Relationship do end) |> Enum.sort |> List.last |> div(365) end + def load_events(%Relationship{ + events: %Ecto.Association.NotLoaded{}} = model) do + model + |> @repo.preload([:events]) + end + def load_events(%Relationship{} = r), do: r + def load_preloads(%Relationship{ + events: %Ecto.Association.NotLoaded{}} = model) do + model + |> @repo.preload([:events]) + end + def load_preloads(%Relationship{} = r), do: r + end diff --git a/friends/test/friends/friend_test.exs b/friends/test/friends/friends_test.exs similarity index 77% rename from friends/test/friends/friend_test.exs rename to friends/test/friends/friends_test.exs index e4f9cad..c8c76fc 100644 --- a/friends/test/friends/friend_test.exs +++ b/friends/test/friends/friends_test.exs @@ -1,4 +1,4 @@ -defmodule Friends.FriendTest do +defmodule Friends.FriendsTest do use Friends.DataCase alias Friends.Friend @@ -84,29 +84,35 @@ defmodule Friends.FriendTest do describe "preloads" do setup do - %{friend: - %{ - Friend.new | id: 123 - } - } + %{friend: Friend.new(%{id: 123})} + end + + test "default nothing loaded", %{friend: friend} do + f = friend + refute f.user |> Ecto.assoc_loaded? + refute f.relationships |> Ecto.assoc_loaded? + refute f.reverse_relationships |> Ecto.assoc_loaded? end test "load user", %{friend: friend} do f = friend |> Friend.load_user - refute f.user == %Ecto.Association.NotLoaded{} + assert f.user |> Ecto.assoc_loaded? + refute f.relationships |> Ecto.assoc_loaded? + refute f.reverse_relationships |> Ecto.assoc_loaded? end test "load relationships", %{friend: friend} do f = friend |> Friend.load_relationships - refute f.relationships == %Ecto.Association.NotLoaded{} - refute f.reverse_relationships == %Ecto.Association.NotLoaded{} + refute f.user |> Ecto.assoc_loaded? + assert f.relationships |> Ecto.assoc_loaded? + assert f.reverse_relationships |> Ecto.assoc_loaded? end test "load all", %{friend: friend} do f = friend |> Friend.load_preloads - refute f.user == %Ecto.Association.NotLoaded{} - refute f.relationships == %Ecto.Association.NotLoaded{} - refute f.reverse_relationships == %Ecto.Association.NotLoaded{} + assert f.user |> Ecto.assoc_loaded? + assert f.relationships |> Ecto.assoc_loaded? + assert f.reverse_relationships |> Ecto.assoc_loaded? end end diff --git a/friends/test/friends/relationships_test.exs b/friends/test/friends/relationships_test.exs new file mode 100644 index 0000000..4b5f7cd --- /dev/null +++ b/friends/test/friends/relationships_test.exs @@ -0,0 +1,63 @@ +defmodule Friends.RelationshipsTest do + use Friends.DataCase + import Friends.FriendsFixtures + alias Friends.{Friend, Relationship} + + setup do + friend1 = friend_fixture() + friend2 = friend_fixture() + %{ + friend1: friend1, + friend2: friend2, + relationship: Relationship.new( + friend1, friend2 + ) + } + end + + describe "init relationships" do + test "defaults to nothing", %{friend1: friend1, friend2: friend2} do + refute friend2 in friend1.relationships + refute friend1 in friend2.relationships + end + end + + describe "types" do + test "defaults to friends", %{relationship: r} do + assert (r.type |> Relationship.types) == { + :friends, :secondary, :friend + } + + assert (r |> Relationship.get_type) == :friends + assert (r |> Relationship.get_color) == :secondary + assert (r |> Relationship.get_relation) == :friend + + end + end + + + describe "preloads" do + setup do + %{relationship: Relationship.new( + friend_fixture(), friend_fixture()) + } + end + + test "default nothing loaded", %{relationship: relationship} do + r = relationship + refute r.events |> Ecto.assoc_loaded? + end + + test "load events", %{relationship: relationship} do + r = relationship |> Relationship.load_events + assert r.events |> Ecto.assoc_loaded? + end + + test "load all", %{relationship: relationship} do + r = relationship |> Relationship.load_preloads + assert r.events |> Ecto.assoc_loaded? + end + + end + +end diff --git a/friends/test/friends_web/controllers/friend_controller_test.exs b/friends/test/friends_web/controllers/friend_controller_test.exs index 722a990..3696061 100644 --- a/friends/test/friends_web/controllers/friend_controller_test.exs +++ b/friends/test/friends_web/controllers/friend_controller_test.exs @@ -2,13 +2,10 @@ defmodule FriendsWeb.FriendControllerTest do use FriendsWeb.ConnCase, async: true import Friends.{AccountsFixtures,FriendsFixtures} - alias FriendsWeb.Router.Helpers, as: Routes - - setup do %{ - user: user, - friend: friend + user: _user, + friend: _friend } = friend_fixture( %{email: user_fixture().email}