Start relationship tests; create events

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

friends/lib/friends/friend.ex

@@ -104,7 +104,7 @@ defmodule Friends.Friend do
     changeset
     |> generate_slug
     |> @repo.insert!
-    |> load_user
+    |> load_preloads
   end
 
 

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

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: Friend.new(%{id: 123})}
-        %{
+    end
-          Friend.new | id: 123
+
-        }
+    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.user |> Ecto.assoc_loaded?
-      refute f.reverse_relationships == %Ecto.Association.NotLoaded{}
+      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{}
+      assert f.user |> Ecto.assoc_loaded?
-      refute f.relationships == %Ecto.Association.NotLoaded{}
+      assert f.relationships |> Ecto.assoc_loaded?
-      refute f.reverse_relationships == %Ecto.Association.NotLoaded{}
+      assert f.reverse_relationships |> Ecto.assoc_loaded?
     end
 
   end

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

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,
+      user: _user,
-      friend: friend
+      friend: _friend
      } =
       friend_fixture(
         %{email: user_fixture().email}