More tests

test/eventos/actors/actors_test.exs

@@ -9,7 +9,7 @@ defmodule Eventos.ActorsTest do
 
     @valid_attrs %{
       summary: "some description",
-      name: "some name",
+      name: "Bobby Blank",
       domain: "some domain",
       keys: "some keypair",
       suspended: true,
@@ -74,7 +74,7 @@ defmodule Eventos.ActorsTest do
     end
 
     test "get_actor_by_name/1 returns a remote actor" do
-      assert %Actor{} = actor = Actors.get_or_fetch_by_url(@remote_account_url)
+      assert {:ok, %Actor{} = actor} = Actors.get_or_fetch_by_url(@remote_account_url)
       actor_found = Actors.get_actor_by_name("#{actor.preferred_username}@#{actor.domain}")
       assert actor_found = actor
     end
@@ -107,7 +107,7 @@ defmodule Eventos.ActorsTest do
     end
 
     test "get_actor_by_name_with_everything!/1 returns the remote actor with it's organized events" do
-      assert %Actor{} = actor = Actors.get_or_fetch_by_url(@remote_account_url)
+      assert {:ok, %Actor{} = actor} = Actors.get_or_fetch_by_url(@remote_account_url)
 
       assert Actors.get_actor_by_name_with_everything(
                "#{actor.preferred_username}@#{actor.domain}"
@@ -124,12 +124,15 @@ defmodule Eventos.ActorsTest do
     test "get_or_fetch_by_url/1 returns the local actor for the url", %{
       actor: actor
     } do
-      assert Actors.get_or_fetch_by_url(actor.url).preferred_username == actor.preferred_username
-      assert Actors.get_or_fetch_by_url(actor.url).domain == nil
+      preferred_username = actor.preferred_username
+
+      assert {:ok, %Actor{preferred_username: preferred_username, domain: nil} = actor_found} =
+               Actors.get_or_fetch_by_url(actor.url)
     end
 
     test "get_or_fetch_by_url/1 returns the remote actor for the url" do
-      assert %Actor{preferred_username: @remote_account_username, domain: @remote_account_domain} =
+      assert {:ok,
+              %Actor{preferred_username: @remote_account_username, domain: @remote_account_domain}} =
                Actors.get_or_fetch_by_url(@remote_account_url)
     end
 
@@ -141,12 +144,21 @@ defmodule Eventos.ActorsTest do
       assert actors = [actor, actor2]
     end
 
-    test "test find_actors_by_username/1 returns actors with similar usernames", %{actor: actor} do
-      %Actor{} = actor2 = Actors.get_or_fetch_by_url(@remote_account_url)
-      actors = Actors.find_actors_by_username("t")
+    test "test find_actors_by_username_or_name/1 returns actors with similar usernames", %{
+      actor: actor
+    } do
+      {:ok, %Actor{} = actor2} = Actors.get_or_fetch_by_url(@remote_account_url)
+      actors = Actors.find_actors_by_username_or_name("t")
       assert actors = [actor, actor2]
     end
 
+    test "test find_actors_by_username_or_name/1 returns actors with similar names", %{
+      actor: actor
+    } do
+      actors = Actors.find_actors_by_username_or_name("ohno")
+      assert actors == []
+    end
+
     test "test search/1 returns accounts for search with existing accounts", %{actor: actor} do
       assert {:ok, [actor]} = Actors.search("t")
     end
@@ -180,7 +192,7 @@ defmodule Eventos.ActorsTest do
     test "create_actor/1 with valid data creates a actor" do
       assert {:ok, %Actor{} = actor} = Actors.create_actor(@valid_attrs)
       assert actor.summary == "some description"
-      assert actor.name == "some name"
+      assert actor.name == "Bobby Blank"
       assert actor.domain == "some domain"
       assert actor.keys == "some keypair"
       assert actor.suspended
@@ -484,4 +496,97 @@ defmodule Eventos.ActorsTest do
       assert %Ecto.Changeset{} = Actors.change_follower(follower)
     end
   end
+
+  describe "members" do
+    alias Eventos.Actors.Member
+    alias Eventos.Actors.Actor
+
+    @valid_attrs %{approved: true, role: 0}
+    @update_attrs %{approved: false, role: 1}
+    @invalid_attrs %{approved: nil, role: nil}
+
+    setup do
+      actor = insert(:actor)
+      group = insert(:group)
+      {:ok, actor: actor, group: group}
+    end
+
+    defp create_member(%{actor: actor, group: group}) do
+      insert(:member, actor: actor, parent: group)
+    end
+
+    test "get_member!/1 returns the member with given id", context do
+      member = create_member(context)
+      assert member = Actors.get_member!(member.id)
+    end
+
+    test "create_member/1 with valid data creates a member", %{
+      actor: actor,
+      group: group
+    } do
+      valid_attrs =
+        @valid_attrs
+        |> Map.put(:actor_id, actor.id)
+        |> Map.put(:parent_id, group.id)
+
+      assert {:ok, %Member{} = member} = Actors.create_member(valid_attrs)
+      assert member.approved == true
+      assert member.role == 0
+
+      assert [group] = Actor.get_groups_member_of(actor)
+      assert [actor] = Actor.get_members_for_group(group)
+    end
+
+    test "create_member/1 with valid data but same actors fails to create a member", %{
+      actor: actor,
+      group: group
+    } do
+      create_member(%{actor: actor, group: group})
+
+      valid_attrs =
+        @valid_attrs
+        |> Map.put(:actor_id, actor.id)
+        |> Map.put(:parent_id, group.id)
+
+      assert {:error, _member} = Actors.create_member(valid_attrs)
+    end
+
+    test "create_member/1 with invalid data returns error changeset", %{
+      actor: actor,
+      group: group
+    } do
+      invalid_attrs =
+        @invalid_attrs
+        |> Map.put(:actor_id, nil)
+        |> Map.put(:parent_id, nil)
+
+      assert {:error, %Ecto.Changeset{}} = Actors.create_member(invalid_attrs)
+    end
+
+    test "update_member/2 with valid data updates the member", context do
+      member = create_member(context)
+      assert {:ok, member} = Actors.update_member(member, @update_attrs)
+      assert %Member{} = member
+      assert member.approved == false
+      assert member.role == 1
+    end
+
+    # This can't happen, since attrs are optional
+    # test "update_member/2 with invalid data returns error changeset", context do
+    #   member = create_member(context)
+    #   assert {:error, %Ecto.Changeset{}} = Actors.update_member(member, @invalid_attrs)
+    #   assert member = Actors.get_member!(member.id)
+    # end
+
+    test "delete_member/1 deletes the member", context do
+      member = create_member(context)
+      assert {:ok, %Member{}} = Actors.delete_member(member)
+      assert_raise Ecto.NoResultsError, fn -> Actors.get_member!(member.id) end
+    end
+
+    test "change_member/1 returns a member changeset", context do
+      member = create_member(context)
+      assert %Ecto.Changeset{} = Actors.change_member(member)
+    end
+  end
 end

test/eventos/events/events_test.exs

@@ -32,6 +32,12 @@ defmodule Eventos.EventsTest do
   describe "events" do
     alias Eventos.Events.Event
 
+    setup do
+      actor = insert(:actor)
+      event = insert(:event, organizer_actor: actor)
+      {:ok, actor: actor, event: event}
+    end
+
     @valid_attrs %{
       begins_on: "2010-04-17 14:00:00.000000Z",
       description: "some description",
@@ -46,14 +52,32 @@ defmodule Eventos.EventsTest do
     }
     @invalid_attrs %{begins_on: nil, description: nil, ends_on: nil, title: nil}
 
-    test "list_events/0 returns all events" do
-      event = event_fixture()
-      assert hd(Events.list_events()).title == event.title
+    test "list_events/0 returns all events", %{event: event} do
+      assert event.title == hd(Events.list_events()).title
     end
 
-    test "get_event!/1 returns the event with given id" do
-      event = event_fixture()
+    test "get_event!/1 returns the event with given id", %{event: event} do
       assert Events.get_event!(event.id).title == event.title
+      refute Ecto.assoc_loaded?(Events.get_event!(event.id).organizer_actor)
+    end
+
+    test "get_event_full!/1 returns the event with given id", %{event: event} do
+      assert Events.get_event_full!(event.id).organizer_actor.preferred_username ==
+               event.organizer_actor.preferred_username
+
+      assert Events.get_event_full!(event.id).participants == []
+    end
+
+    test "find_events_by_name/1 returns events for a given name", %{event: event} do
+      assert event.title == hd(Events.find_events_by_name(event.title)).title
+
+      event2 = insert(:event, title: "Special event")
+      assert event2.title == hd(Events.find_events_by_name("Special")).title
+
+      event2 = insert(:event, title: "Special event")
+      assert event2.title == hd(Events.find_events_by_name("  Special  ")).title
+
+      assert [] == Events.find_events_by_name("")
     end
 
     test "create_event/1 with valid data creates a event" do
@@ -79,8 +103,7 @@ defmodule Eventos.EventsTest do
       assert {:error, %Ecto.Changeset{}} = Events.create_event(@invalid_attrs)
     end
 
-    test "update_event/2 with valid data updates the event" do
-      event = event_fixture()
+    test "update_event/2 with valid data updates the event", %{event: event} do
       assert {:ok, event} = Events.update_event(event, @update_attrs)
       assert %Event{} = event
       assert event.begins_on == DateTime.from_naive!(~N[2011-05-18 15:01:01.000000Z], "Etc/UTC")
@@ -89,27 +112,44 @@ defmodule Eventos.EventsTest do
       assert event.title == "some updated title"
     end
 
-    test "update_event/2 with invalid data returns error changeset" do
-      event = event_fixture()
+    test "update_event/2 with invalid data returns error changeset", %{event: event} do
       assert {:error, %Ecto.Changeset{}} = Events.update_event(event, @invalid_attrs)
       assert event.title == Events.get_event!(event.id).title
     end
 
-    test "delete_event/1 deletes the event" do
-      event = event_fixture()
+    test "delete_event/1 deletes the event", %{event: event} do
       assert {:ok, %Event{}} = Events.delete_event(event)
       assert_raise Ecto.NoResultsError, fn -> Events.get_event!(event.id) end
     end
 
-    test "change_event/1 returns a event changeset" do
-      event = event_fixture()
+    test "change_event/1 returns a event changeset", %{event: event} do
       assert %Ecto.Changeset{} = Events.change_event(event)
     end
+
+    test "get_events_for_actor/1", %{actor: actor, event: event} do
+      assert {:ok, [event_found], 1} = Events.get_events_for_actor(actor)
+      assert event_found.title == event.title
+    end
+
+    test "get_events_for_actor/3", %{actor: actor, event: event} do
+      event1 = insert(:event, organizer_actor: actor)
+      assert {:ok, [event_found, event1_found], 2} = Events.get_events_for_actor(actor, 1, 10)
+    end
+
+    test "get_events_for_actor/3 with limited results", %{actor: actor, event: event} do
+      event1 = insert(:event, organizer_actor: actor)
+      assert {:ok, [event_found], 2} = Events.get_events_for_actor(actor, 1, 1)
+    end
   end
 
   describe "categories" do
     alias Eventos.Events.Category
 
+    setup do
+      category = insert(:category)
+      {:ok, category: category}
+    end
+
     @valid_attrs %{description: "some description", picture: "some picture", title: "some title"}
     @update_attrs %{
       description: "some updated description",
@@ -118,16 +158,18 @@ defmodule Eventos.EventsTest do
     }
     @invalid_attrs %{description: nil, picture: nil, title: nil}
 
-    test "list_categories/0 returns all categories" do
-      category = category_fixture()
+    test "list_categories/0 returns all categories", %{category: category} do
       assert Events.list_categories() == [category]
     end
 
-    test "get_category!/1 returns the category with given id" do
-      category = category_fixture()
+    test "get_category!/1 returns the category with given id", %{category: category} do
       assert Events.get_category!(category.id) == category
     end
 
+    test "get_category_by_title/1 return the category with given title", %{category: category} do
+      assert Events.get_category_by_title(category.title) == category
+    end
+
     test "create_category/1 with valid data creates a category" do
       assert {:ok, %Category{} = category} = Events.create_category(@valid_attrs)
       assert category.description == "some description"
@@ -139,8 +181,7 @@ defmodule Eventos.EventsTest do
       assert {:error, %Ecto.Changeset{}} = Events.create_category(@invalid_attrs)
     end
 
-    test "update_category/2 with valid data updates the category" do
-      category = category_fixture()
+    test "update_category/2 with valid data updates the category", %{category: category} do
       assert {:ok, category} = Events.update_category(category, @update_attrs)
       assert %Category{} = category
       assert category.description == "some updated description"
@@ -148,20 +189,17 @@ defmodule Eventos.EventsTest do
       assert category.title == "some updated title"
     end
 
-    test "update_category/2 with invalid data returns error changeset" do
-      category = category_fixture()
+    test "update_category/2 with invalid data returns error changeset", %{category: category} do
       assert {:error, %Ecto.Changeset{}} = Events.update_category(category, @invalid_attrs)
       assert category == Events.get_category!(category.id)
     end
 
-    test "delete_category/1 deletes the category" do
-      category = category_fixture()
+    test "delete_category/1 deletes the category", %{category: category} do
       assert {:ok, %Category{}} = Events.delete_category(category)
       assert_raise Ecto.NoResultsError, fn -> Events.get_category!(category.id) end
     end
 
-    test "change_category/1 returns a category changeset" do
-      category = category_fixture()
+    test "change_category/1 returns a category changeset", %{category: category} do
       assert %Ecto.Changeset{} = Events.change_category(category)
     end
   end
@@ -227,35 +265,31 @@ defmodule Eventos.EventsTest do
   end
 
   describe "participants" do
-    alias Eventos.Events.Participant
+    alias Eventos.Events.{Participant, Event}
+    alias Eventos.Actors.Actor
 
     @valid_attrs %{role: 42}
     @update_attrs %{role: 43}
     @invalid_attrs %{role: nil}
 
-    def participant_fixture(attrs \\ %{}) do
-      event = event_fixture()
-      actor = actor_fixture()
-      valid_attrs = Map.put(@valid_attrs, :event_id, event.id)
-      valid_attrs = Map.put(valid_attrs, :actor_id, actor.id)
-
-      {:ok, participant} =
-        attrs
-        |> Enum.into(valid_attrs)
-        |> Events.create_participant()
-
-      participant
+    setup do
+      actor = insert(:actor)
+      event = insert(:event, organizer_actor: actor)
+      participant = insert(:participant, actor: actor, event: event)
+      {:ok, participant: participant, event: event, actor: actor}
     end
 
-    test "list_participants/0 returns all participants" do
-      participant = participant_fixture()
-      assert Events.list_participants() == [participant]
+    test "list_participants/0 returns all participants", %{participant: participant} do
+      assert [%Participant{} = participant] = Events.list_participants()
     end
 
-    #    test "get_participant!/1 returns the participant with given id" do
-    #      participant = participant_fixture()
-    #      assert Events.get_participant!(participant.id) == participant
-    #    end
+    test "get_participant!/1 returns the participant for a given event and given actor", %{
+      event: %Event{id: event_id} = _event,
+      actor: %Actor{id: actor_id} = _actor
+    } do
+      assert %Participant{event_id: event_id, actor_id: actor_id} =
+               _participant = Events.get_participant!(event_id, actor_id)
+    end
 
     test "create_participant/1 with valid data creates a participant" do
       actor = actor_fixture()
@@ -270,25 +304,25 @@ defmodule Eventos.EventsTest do
       assert {:error, %Ecto.Changeset{}} = Events.create_participant(@invalid_attrs)
     end
 
-    test "update_participant/2 with valid data updates the participant" do
-      participant = participant_fixture()
+    test "update_participant/2 with valid data updates the participant", %{
+      participant: participant
+    } do
       assert {:ok, participant} = Events.update_participant(participant, @update_attrs)
       assert %Participant{} = participant
       assert participant.role == 43
     end
 
-    test "update_participant/2 with invalid data returns error changeset" do
-      participant = participant_fixture()
+    test "update_participant/2 with invalid data returns error changeset", %{
+      participant: participant
+    } do
       assert {:error, %Ecto.Changeset{}} = Events.update_participant(participant, @invalid_attrs)
     end
 
-    test "delete_participant/1 deletes the participant" do
-      participant = participant_fixture()
+    test "delete_participant/1 deletes the participant", %{participant: participant} do
       assert {:ok, %Participant{}} = Events.delete_participant(participant)
     end
 
-    test "change_participant/1 returns a participant changeset" do
-      participant = participant_fixture()
+    test "change_participant/1 returns a participant changeset", %{participant: participant} do
       assert %Ecto.Changeset{} = Events.change_participant(participant)
     end
   end

test/eventos/service/activitypub/activitypub_test.exs

@@ -5,14 +5,20 @@ defmodule Eventos.Service.Activitypub.ActivitypubTest do
 
   alias Eventos.Events
   alias Eventos.Actors.Actor
+  alias Eventos.Actors
   alias Eventos.Service.ActivityPub
   alias Eventos.Activity
 
   describe "fetching actor from it's url" do
-    test "returns an actor" do
+    test "returns an actor from nickname" do
       assert {:ok, %Actor{preferred_username: "tcit", domain: "framapiaf.org"} = actor} =
                ActivityPub.make_actor_from_nickname("tcit@framapiaf.org")
     end
+
+    test "returns an actor from url" do
+      assert {:ok, %Actor{preferred_username: "tcit", domain: "framapiaf.org"}} =
+               Actors.get_or_fetch_by_url("https://framapiaf.org/users/tcit")
+    end
   end
 
   describe "create activities" do
@@ -33,8 +39,8 @@ defmodule Eventos.Service.Activitypub.ActivitypubTest do
     end
   end
 
-  describe "fetching an object" do
-    test "it fetches an object" do
+  describe "fetching an" do
+    test "event by url" do
       {:ok, object} =
         ActivityPub.fetch_event_from_url("https://social.tcit.fr/@tcit/99908779444618462")
 
@@ -55,7 +61,19 @@ defmodule Eventos.Service.Activitypub.ActivitypubTest do
       assert delete.data["actor"] == event.organizer_actor.url
       assert delete.data["object"] == event.url
 
-      assert Events.get_event_by_url!(event.url) == nil
+      assert Events.get_event_by_url(event.url) == nil
+    end
+
+    test "it creates a delete activity and deletes the original comment" do
+      comment = insert(:comment)
+      comment = Events.get_comment_full_from_url!(comment.url)
+      {:ok, delete} = ActivityPub.delete(comment)
+
+      assert delete.data["type"] == "Delete"
+      assert delete.data["actor"] == comment.actor.url
+      assert delete.data["object"] == comment.url
+
+      assert Events.get_comment_from_url(comment.url) == nil
     end
   end
 

test/eventos_web/controllers/activity_pub_controller_test.exs

@@ -3,10 +3,11 @@ defmodule EventosWeb.ActivityPubControllerTest do
   import Eventos.Factory
   alias EventosWeb.ActivityPub.{ActorView, ObjectView}
   alias Eventos.{Repo, Actors, Actors.Actor}
+  alias Eventos.Service.ActivityPub
   alias Eventos.Activity
   import Logger
 
-  describe "/@:username" do
+  describe "/@:preferred_username" do
     test "it returns a json representation of the actor", %{conn: conn} do
       actor = insert(:actor)
 
@@ -22,8 +23,8 @@ defmodule EventosWeb.ActivityPubControllerTest do
     end
   end
 
-  describe "/events/uuid" do
-    test "it returns a json representation of the object", %{conn: conn} do
+  describe "/events/:uuid" do
+    test "it returns a json representation of the event", %{conn: conn} do
       event = insert(:event)
 
       conn =
@@ -34,23 +35,60 @@ defmodule EventosWeb.ActivityPubControllerTest do
       assert json_response(conn, 200) == ObjectView.render("event.json", %{event: event})
       Logger.error(inspect(ObjectView.render("event.json", %{event: event})))
     end
+
+    test "it returns 404 for non-public events", %{conn: conn} do
+      event = insert(:event, public: false)
+
+      conn =
+        conn
+        |> put_req_header("accept", "application/activity+json")
+        |> get("/events/#{event.uuid}")
+
+      assert json_response(conn, 404)
+    end
   end
 
-  #  describe "/actors/:username/inbox" do
-  #    test "it inserts an incoming activity into the database", %{conn: conn} do
-  #      data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
-  #
-  #      conn =
-  #        conn
-  #        |> assign(:valid_signature, true)
-  #        |> put_req_header("content-type", "application/activity+json")
-  #        |> post("/inbox", data)
-  #
-  #      assert "ok" == json_response(conn, 200)
-  #      :timer.sleep(500)
-  #      assert Activity.get_by_ap_id(data["id"])
-  #    end
-  #  end
+  describe "/@:preferred_username/inbox" do
+    test "it inserts an incoming event into the database", %{conn: conn} do
+      data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
+
+      conn =
+        conn
+        |> assign(:valid_signature, true)
+        |> put_req_header("content-type", "application/activity+json")
+        |> post("/inbox", data)
+
+      assert "ok" == json_response(conn, 200)
+      :timer.sleep(500)
+      assert ActivityPub.fetch_object_from_url(data["object"]["id"], :note)
+    end
+  end
+
+  describe "/@:preferred_username/outbox" do
+    test "it returns a note activity in a collection", %{conn: conn} do
+      actor = insert(:actor)
+      comment = insert(:comment, actor: actor)
+
+      conn =
+        conn
+        |> put_req_header("accept", "application/activity+json")
+        |> get("/@#{actor.preferred_username}/outbox")
+
+      assert response(conn, 200) =~ comment.text
+    end
+
+    test "it returns an event activity in a collection", %{conn: conn} do
+      actor = insert(:actor)
+      event = insert(:event, organizer_actor: actor)
+
+      conn =
+        conn
+        |> put_req_header("accept", "application/activity+json")
+        |> get("/@#{actor.preferred_username}/outbox")
+
+      assert response(conn, 200) =~ event.title
+    end
+  end
 
   #  describe "/actors/:nickname/followers" do
   #    test "it returns the followers in a collection", %{conn: conn} do
@@ -93,43 +131,43 @@ defmodule EventosWeb.ActivityPubControllerTest do
   #    end
   #  end
   #
-  #  describe "/users/:nickname/following" do
+  #  describe "/@:preferred_username/following" do
   #    test "it returns the following in a collection", %{conn: conn} do
-  #      user = insert(:user)
-  #      user_two = insert(:user)
-  #      User.follow(user, user_two)
-  #
+  #      actor = insert(:actor)
+  #      actor2 = insert(:actor)
+  #      Eventos.Service.ActivityPub.follow(actor, actor2)
+
   #      result =
   #        conn
-  #        |> get("/users/#{user.nickname}/following")
+  #        |> get("/@#{actor.preferred_username}/following")
   #        |> json_response(200)
-  #
-  #      assert result["first"]["orderedItems"] == [user_two.ap_id]
+
+  #      assert result["first"]["orderedItems"] == [actor2.url]
   #    end
-  #
-  #    test "it works for more than 10 users", %{conn: conn} do
-  #      user = insert(:user)
-  #
+
+  #    test "it works for more than 10 actors", %{conn: conn} do
+  #      actor = insert(:actor)
+
   #      Enum.each(1..15, fn _ ->
-  #        user = Repo.get(User, user.id)
-  #        other_user = insert(:user)
-  #        User.follow(user, other_user)
+  #        actor = Repo.get(Actor, actor.id)
+  #        other_actor = insert(:actor)
+  #        Actor.follow(actor, other_actor)
   #      end)
-  #
+
   #      result =
   #        conn
-  #        |> get("/users/#{user.nickname}/following")
+  #        |> get("/@#{actor.preferred_username}/following")
   #        |> json_response(200)
-  #
+
   #      assert length(result["first"]["orderedItems"]) == 10
   #      assert result["first"]["totalItems"] == 15
   #      assert result["totalItems"] == 15
-  #
+
   #      result =
   #        conn
-  #        |> get("/users/#{user.nickname}/following?page=2")
+  #        |> get("/@#{actor.preferred_username}/following?page=2")
   #        |> json_response(200)
-  #
+
   #      assert length(result["orderedItems"]) == 5
   #      assert result["totalItems"] == 15
   #    end

test/eventos_web/controllers/actor_controller_test.exs

@@ -31,6 +31,64 @@ defmodule EventosWeb.ActorControllerTest do
     end
   end
 
+  describe "show actor" do
+    test "show existing actor", %{conn: conn, actor: actor} do
+      actor_id = actor.id
+      conn = get(conn, actor_path(conn, :show, actor.preferred_username))
+      assert %{"data" => %{"id" => actor_id}} = json_response(conn, 200)
+    end
+
+    test "show non-existing actor", %{conn: conn, actor: actor} do
+      actor_id = actor.id
+      conn = get(conn, actor_path(conn, :show, "nonexisting"))
+      assert "" == response(conn, 404)
+    end
+  end
+
+  describe "search for actors" do
+    test "search for existing actors", %{conn: conn, actor: actor} do
+      actor_username = actor.preferred_username
+      conn = get(conn, actor_path(conn, :search, actor_username))
+      assert %{"data" => [%{"username" => actor_username}]} = json_response(conn, 200)
+    end
+
+    test "search for existing actors with similar username", %{conn: conn, actor: actor} do
+      actor_username = actor.preferred_username
+      conn = get(conn, actor_path(conn, :search, "thom"))
+      assert %{"data" => [%{"username" => actor_username}]} = json_response(conn, 200)
+    end
+
+    test "search for nothing", %{conn: conn, actor: actor} do
+      actor_username = actor.preferred_username
+      conn = get(conn, actor_path(conn, :search, "nothing"))
+      assert %{"data" => []} = json_response(conn, 200)
+    end
+  end
+
+  describe "update actor" do
+    test "update actor with valid attrs", %{conn: conn, user: user, actor: actor} do
+      conn = auth_conn(conn, user)
+
+      conn =
+        patch(conn, actor_path(conn, :update, actor.preferred_username), %{
+          "actor" => %{"name" => "glouglou"}
+        })
+
+      assert %{"data" => %{"display_name" => "glouglou"}} = json_response(conn, 200)
+    end
+
+    test "update actor with invalid attrs", %{conn: conn, user: user, actor: actor} do
+      conn = auth_conn(conn, user)
+
+      conn =
+        patch(conn, actor_path(conn, :update, actor.preferred_username), %{
+          "actor" => %{"preferred_username" => nil}
+        })
+
+      assert json_response(conn, 422)["errors"] != %{}
+    end
+  end
+
   ###
   # Not possible atm
   ###

test/eventos_web/controllers/address_controller_test.exs

@@ -34,7 +34,7 @@ defmodule EventosWeb.AddressControllerTest do
     floor: nil,
     postalCode: nil,
     streetAddress: nil,
-    geom: %{type: nil, data: %{latitude: nil, longitude: nil}}
+    geom: %{type: "oh no", data: %{latitude: nil, longitude: nil}}
   }
 
   def fixture(:address) do

test/eventos_web/controllers/user_controller_test.exs

@@ -5,6 +5,7 @@ defmodule EventosWeb.UserControllerTest do
 
   alias Eventos.Actors
   alias Eventos.Actors.User
+  use Bamboo.Test
 
   @create_attrs %{email: "foo@bar.tld", password: "some password_hash", username: "some username"}
   # @update_attrs %{email: "foo@fighters.tld", password: "some updated password_hash", username: "some updated username"}
@@ -18,7 +19,7 @@ defmodule EventosWeb.UserControllerTest do
   setup %{conn: conn} do
     user = insert(:user)
     actor = insert(:actor, user: user)
-    {:ok, conn: conn, user: user}
+    {:ok, conn: conn, user: user, actor: actor}
   end
 
   describe "index" do
@@ -31,12 +32,14 @@ defmodule EventosWeb.UserControllerTest do
 
   describe "create user" do
     test "renders user when data is valid", %{conn: conn} do
-      conn = post(conn, user_path(conn, :create), @create_attrs)
+      conn = post(conn, user_path(conn, :register), @create_attrs)
       assert %{"email" => "foo@bar.tld"} = json_response(conn, 201)
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(@create_attrs.email)
+      assert_delivered_email(Eventos.Email.User.confirmation_email(user))
     end
 
     test "renders errors when data is invalid", %{conn: conn} do
-      conn = post(conn, user_path(conn, :create), @invalid_attrs)
+      conn = post(conn, user_path(conn, :register), @invalid_attrs)
       assert json_response(conn, 422)["errors"] != %{}
     end
 
@@ -47,11 +50,139 @@ defmodule EventosWeb.UserControllerTest do
         username: "framasoft"
       }
 
-      conn = post(conn, user_path(conn, :create), attrs)
+      conn = post(conn, user_path(conn, :register), attrs)
       assert %{"email" => "contact@framasoft.org"} = json_response(conn, 201)
     end
   end
 
+  describe "validating user" do
+    test "validate user when token is valid", %{conn: conn} do
+      conn = post(conn, user_path(conn, :create), @create_attrs)
+      assert %{"email" => "foo@bar.tld"} = json_response(conn, 201)
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(@create_attrs.email)
+      assert_delivered_email(Eventos.Email.User.confirmation_email(user))
+
+      conn = get(conn, user_path(conn, :validate, user.confirmation_token))
+      assert %{"user" => _, "token" => _} = json_response(conn, 200)
+    end
+
+    test "validate user when token is invalid", %{conn: conn} do
+      conn = post(conn, user_path(conn, :create), @create_attrs)
+      assert %{"email" => "foo@bar.tld"} = json_response(conn, 201)
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(@create_attrs.email)
+      assert_delivered_email(Eventos.Email.User.confirmation_email(user))
+
+      conn = get(conn, user_path(conn, :validate, "toto"))
+      assert %{"error" => _} = json_response(conn, 404)
+    end
+  end
+
+  describe "revalidating user" do
+    test "ask to resend token to user when too soon", %{conn: conn} do
+      conn = post(conn, user_path(conn, :create), @create_attrs)
+      assert %{"email" => "foo@bar.tld"} = json_response(conn, 201)
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(@create_attrs.email)
+      assert_delivered_email(Eventos.Email.User.confirmation_email(user))
+
+      conn = post(conn, user_path(conn, :resend_confirmation), %{"email" => @create_attrs.email})
+      assert %{"error" => _} = json_response(conn, 404)
+    end
+
+    test "ask to resend token to user when the time is right", %{conn: conn} do
+      conn = post(conn, user_path(conn, :create), @create_attrs)
+
+      assert %{"email" => "foo@bar.tld"} = json_response(conn, 201)
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(@create_attrs.email)
+      assert_delivered_email(Eventos.Email.User.confirmation_email(user))
+
+      # Hammer time !
+      {:ok, %User{} = user} =
+        Eventos.Actors.update_user(user, %{
+          confirmation_sent_at: Timex.shift(user.confirmation_sent_at, hours: -3)
+        })
+
+      conn = post(conn, user_path(conn, :resend_confirmation), %{"email" => @create_attrs.email})
+      assert_delivered_email(Eventos.Email.User.confirmation_email(user))
+      assert %{"email" => "foo@bar.tld"} = json_response(conn, 200)
+    end
+  end
+
+  describe "resetting user's password" do
+    test "ask for reset", %{conn: conn, user: user} do
+      user_email = user.email
+
+      # Send reset email
+      conn = post(conn, user_path(conn, :send_reset_password), %{"email" => user_email})
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(user.email)
+      assert_delivered_email(Eventos.Email.User.reset_password_email(user))
+      assert %{"email" => user_email} = json_response(conn, 200)
+
+      # Call reset route
+      conn =
+        post(conn, user_path(conn, :reset_password), %{
+          "password" => "new password",
+          "token" => user.reset_password_token
+        })
+
+      user_id = user.id
+      assert %{"user" => %{"id" => user_id}} = json_response(conn, 200)
+    end
+
+    test "ask twice for reset too soon", %{conn: conn, user: user} do
+      user_email = user.email
+
+      # Send reset email
+      conn = post(conn, user_path(conn, :send_reset_password), %{"email" => user.email})
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(user.email)
+      assert_delivered_email(Eventos.Email.User.reset_password_email(user))
+      assert %{"email" => user_email} = json_response(conn, 200)
+
+      # Send reset email again
+      conn = post(conn, user_path(conn, :send_reset_password), %{"email" => user.email})
+
+      assert %{"errors" => "You requested a new reset password too early"} =
+               json_response(conn, 404)
+    end
+
+    test "ask twice for reset after a while", %{conn: conn, user: user} do
+      user_email = user.email
+
+      # Send reset email
+      conn = post(conn, user_path(conn, :send_reset_password), %{"email" => user.email})
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(user.email)
+      assert_delivered_email(Eventos.Email.User.reset_password_email(user))
+      assert %{"email" => user_email} = json_response(conn, 200)
+
+      # Hammer time !
+      {:ok, %User{} = user} =
+        Eventos.Actors.update_user(user, %{
+          reset_password_sent_at: Timex.shift(user.reset_password_sent_at, hours: -3)
+        })
+
+      # Send reset email again
+      conn = post(conn, user_path(conn, :send_reset_password), %{"email" => user.email})
+      assert {:ok, %User{} = user} = Eventos.Actors.get_user_by_email(user.email)
+      assert_delivered_email(Eventos.Email.User.reset_password_email(user))
+      assert %{"email" => user_email} = json_response(conn, 200)
+    end
+
+    test "ask for reset with wrong address", %{conn: conn} do
+      conn = post(conn, user_path(conn, :send_reset_password), %{"email" => "yolo@coucou"})
+      assert %{"errors" => "Unable to find an user with this email"} = json_response(conn, 404)
+    end
+
+    test "calling reset route with wrong token", %{conn: conn} do
+      conn =
+        post(conn, user_path(conn, :reset_password), %{
+          "password" => "new password",
+          "token" => "just wrong"
+        })
+
+      assert %{"errors" => %{"token" => ["Wrong token for password reset"]}} =
+               json_response(conn, 404)
+    end
+  end
+
   #  describe "update user" do
   #    setup [:create_user]
   #

test/fixtures/mastodon-post-activity.json

@@ -0,0 +1,65 @@
+{
+    "@context": [
+        "https://www.w3.org/ns/activitystreams",
+        "https://w3id.org/security/v1",
+        {
+            "Emoji": "toot:Emoji",
+            "Hashtag": "as:Hashtag",
+            "atomUri": "ostatus:atomUri",
+            "conversation": "ostatus:conversation",
+            "inReplyToAtomUri": "ostatus:inReplyToAtomUri",
+            "manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
+            "movedTo": "as:movedTo",
+            "ostatus": "http://ostatus.org#",
+            "sensitive": "as:sensitive",
+            "toot": "http://joinmastodon.org/ns#"
+        }
+    ],
+    "actor": "http://framapiaf.org/users/admin",
+    "cc": [
+        "http://framapiaf.org/users/admin/followers",
+        "http://eventos.com/@tcit"
+    ],
+    "id": "http://framapiaf.org/users/admin/statuses/99512778738411822/activity",
+    "nickname": "lain",
+    "object": {
+        "atomUri": "http://framapiaf.org/users/admin/statuses/99512778738411822",
+        "attachment": [],
+        "attributedTo": "http://framapiaf.org/users/admin",
+        "cc": [
+            "http://framapiaf.org/users/admin/followers",
+            "http://localtesting.pleroma.lol/users/lain"
+        ],
+        "content": "<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>",
+        "conversation": "tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation",
+        "id": "http://framapiaf.org/users/admin/statuses/99512778738411822",
+        "inReplyTo": null,
+        "inReplyToAtomUri": null,
+        "published": "2018-02-12T14:08:20Z",
+        "sensitive": true,
+        "summary": "cw",
+        "tag": [
+            {
+                "href": "http://localtesting.pleroma.lol/users/lain",
+                "name": "@lain@localtesting.pleroma.lol",
+                "type": "Mention"
+            }
+        ],
+        "to": [
+            "https://www.w3.org/ns/activitystreams#Public"
+        ],
+        "type": "Note",
+        "url": "http://framapiaf.org/@admin/99512778738411822"
+    },
+    "published": "2018-02-12T14:08:20Z",
+    "signature": {
+        "created": "2018-02-12T14:08:20Z",
+        "creator": "http://framapiaf.org/users/admin#main-key",
+        "signatureValue": "rnNfcopkc6+Ju73P806popcfwrK9wGYHaJVG1/ZvrlEbWVDzaHjkXqj9Q3/xju5l8CSn9tvSgCCtPFqZsFQwn/pFIFUcw7ZWB2xi4bDm3NZ3S4XQ8JRaaX7og5hFxAhWkGhJhAkfxVnOg2hG+w2d/7d7vRVSC1vo5ip4erUaA/PkWusZvPIpxnRWoXaxJsFmVx0gJgjpJkYDyjaXUlp+jmaoseeZ4EPQUWqHLKJ59PRG0mg8j2xAjYH9nQaN14qMRmTGPxY8gfv/CUFcatA+8VJU9KEsJkDAwLVvglydNTLGrxpAJU78a2eaht0foV43XUIZGe3DKiJPgE+UOKGCJw==",
+        "type": "RsaSignature2017"
+    },
+    "to": [
+        "https://www.w3.org/ns/activitystreams#Public"
+    ],
+    "type": "Create"
+}

test/support/factory.ex

@@ -67,11 +67,14 @@ defmodule Eventos.Factory do
   end
 
   def comment_factory do
+    uuid = Ecto.UUID.generate()
+
     %Eventos.Events.Comment{
       text: "My Comment",
       actor: build(:actor),
       event: build(:event),
-      uuid: Ecto.UUID.generate()
+      uuid: uuid,
+      url: "#{EventosWeb.Endpoint.url()}/comments/#{uuid}"
     }
   end
 
@@ -86,10 +89,18 @@ defmodule Eventos.Factory do
       organizer_actor: actor,
       category: build(:category),
       physical_address: build(:address),
+      public: true,
       url: "#{EventosWeb.Endpoint.url()}/@#{actor.url}/#{Ecto.UUID.generate()}"
     }
   end
 
+  def participant_factory do
+    %Eventos.Events.Participant{
+      event: build(:event),
+      actor: build(:actor)
+    }
+  end
+
   def session_factory do
     %Eventos.Events.Session{
       title: sequence("MySession"),