Introduce follower, add tests

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

test/eventos/actors/actors_test.exs

@@ -38,23 +38,30 @@ defmodule Eventos.ActorsTest do
       preferred_username: nil
     }
 
-    def actor_fixture(attrs \\ %{}) do
-      {:ok, actor} =
-        attrs
-        |> Enum.into(@valid_attrs)
-        |> Actors.create_actor()
+    setup do
+      user = insert(:user)
+      actor = insert(:actor, user: user)
 
-      actor
+      {:ok, actor: actor}
     end
 
-    test "list_actors/0 returns all actors" do
-      actor = actor_fixture()
-      assert Actors.list_actors() == [actor]
+    test "list_actors/0 returns all actors", %{actor: actor} do
+      actors = Actors.list_actors()
+      assert actors = [actor]
     end
 
-    test "get_actor!/1 returns the actor with given id" do
-      actor = actor_fixture()
-      assert Actors.get_actor!(actor.id) == actor
+    test "get_actor!/1 returns the actor with given id", %{actor: actor} do
+      actor_fetched = Actors.get_actor!(actor.id)
+      assert actor_fetched = actor
+    end
+
+    test "get_actor_with_everything!/1 returns the actor with it's organized events", %{
+      actor: actor
+    } do
+      assert Actors.get_actor_with_everything!(actor.id).organized_events == []
+      event = insert(:event, organizer_actor: actor)
+      events = Actors.get_actor_with_everything!(actor.id).organized_events
+      assert events = [event]
     end
 
     test "create_actor/1 with valid data creates a actor" do
@@ -71,8 +78,7 @@ defmodule Eventos.ActorsTest do
       assert {:error, %Ecto.Changeset{}} = Actors.create_actor(@invalid_attrs)
     end
 
-    test "update_actor/2 with valid data updates the actor" do
-      actor = actor_fixture()
+    test "update_actor/2 with valid data updates the actor", %{actor: actor} do
       assert {:ok, actor} = Actors.update_actor(actor, @update_attrs)
       assert %Actor{} = actor
       assert actor.summary == "some updated description"
@@ -83,20 +89,18 @@ defmodule Eventos.ActorsTest do
       assert actor.preferred_username == "some updated username"
     end
 
-    test "update_actor/2 with invalid data returns error changeset" do
-      actor = actor_fixture()
+    test "update_actor/2 with invalid data returns error changeset", %{actor: actor} do
       assert {:error, %Ecto.Changeset{}} = Actors.update_actor(actor, @invalid_attrs)
-      assert actor == Actors.get_actor!(actor.id)
+      actor_fetched = Actors.get_actor!(actor.id)
+      assert actor = actor_fetched
     end
 
-    test "delete_actor/1 deletes the actor" do
-      actor = actor_fixture()
+    test "delete_actor/1 deletes the actor", %{actor: actor} do
       assert {:ok, %Actor{}} = Actors.delete_actor(actor)
       assert_raise Ecto.NoResultsError, fn -> Actors.get_actor!(actor.id) end
     end
 
-    test "change_actor/1 returns a actor changeset" do
-      actor = actor_fixture()
+    test "change_actor/1 returns a actor changeset", %{actor: actor} do
       assert %Ecto.Changeset{} = Actors.change_actor(actor)
     end
   end
@@ -269,4 +273,72 @@ defmodule Eventos.ActorsTest do
       assert %Ecto.Changeset{} = Actors.change_bot(bot)
     end
   end
+
+  describe "followers" do
+    alias Eventos.Actors.Follower
+
+    @valid_attrs %{approved: true, score: 42}
+    @update_attrs %{approved: false, score: 43}
+    @invalid_attrs %{approved: nil, score: nil}
+
+    setup do
+      actor = insert(:actor)
+      target_actor = insert(:actor)
+      follower = insert(:follower, actor: actor, target_actor: target_actor)
+      {:ok, follower: follower, actor: actor, target_actor: target_actor}
+    end
+
+    test "get_follower!/1 returns the follower with given id", %{follower: follower} do
+      follower_fetched = Actors.get_follower!(follower.id)
+      assert follower_fetched = follower
+    end
+
+    test "create_follower/1 with valid data creates a follower", %{
+      actor: actor,
+      target_actor: target_actor
+    } do
+      valid_attrs =
+        @valid_attrs
+        |> Map.put(:actor_id, actor.id)
+        |> Map.put(:target_actor_id, target_actor.id)
+
+      assert {:ok, %Follower{} = follower} = Actors.create_follower(valid_attrs)
+      assert follower.approved == true
+      assert follower.score == 42
+    end
+
+    test "create_follower/1 with invalid data returns error changeset", %{
+      actor: actor,
+      target_actor: target_actor
+    } do
+      invalid_attrs =
+        @invalid_attrs
+        |> Map.put(:actor_id, actor.id)
+        |> Map.put(:target_actor_id, target_actor.id)
+
+      assert {:error, %Ecto.Changeset{}} = Actors.create_follower(invalid_attrs)
+    end
+
+    test "update_follower/2 with valid data updates the follower", %{follower: follower} do
+      assert {:ok, follower} = Actors.update_follower(follower, @update_attrs)
+      assert %Follower{} = follower
+      assert follower.approved == false
+      assert follower.score == 43
+    end
+
+    test "update_follower/2 with invalid data returns error changeset", %{follower: follower} do
+      assert {:error, %Ecto.Changeset{}} = Actors.update_follower(follower, @invalid_attrs)
+      follower_fetched = Actors.get_follower!(follower.id)
+      assert follower = follower_fetched
+    end
+
+    test "delete_follower/1 deletes the follower", %{follower: follower} do
+      assert {:ok, %Follower{}} = Actors.delete_follower(follower)
+      assert_raise Ecto.NoResultsError, fn -> Actors.get_follower!(follower.id) end
+    end
+
+    test "change_follower/1 returns a follower changeset", %{follower: follower} do
+      assert %Ecto.Changeset{} = Actors.change_follower(follower)
+    end
+  end
 end

test/eventos_web/controllers/actor_controller_test.exs

@@ -11,16 +11,9 @@ defmodule EventosWeb.ActorControllerTest do
     {:ok, conn: conn, user: user, actor: actor}
   end
 
-  key = :public_key.generate_key({:rsa, 2048, 65_537})
-  entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
-  pem = [entry] |> :public_key.pem_encode() |> String.trim_trailing()
-
   @create_attrs %{
     preferred_username: "otheridentity",
-    summary: "This is my other identity",
-    domain: nil,
-    keys: pem,
-    user: nil
+    summary: "This is my other identity"
   }
 
   describe "index" do
@@ -61,4 +54,66 @@ defmodule EventosWeb.ActorControllerTest do
   #      assert response(conn, 200)
   #    end
   #  end
+
+  @create_group_attrs %{
+    preferred_username: "mygroup",
+    summary: "This is my awesome group",
+    name: "My Group"
+  }
+
+  describe "index groups" do
+    test "lists all actor groups", %{conn: conn} do
+      conn = get(conn, group_path(conn, :index))
+      assert json_response(conn, 200)["data"] == []
+    end
+
+    test "after creating a group", %{conn: conn, user: user, actor: actor} do
+      # create group
+      conn = auth_conn(conn, user)
+      create_group_attrs = Map.put(@create_group_attrs, :actor_admin, actor.preferred_username)
+      conn = post(conn, group_path(conn, :create), group: create_group_attrs)
+
+      group_res = json_response(conn, 201)
+      assert group_res["username"] == @create_group_attrs.preferred_username
+
+      conn = get(conn, group_path(conn, :index))
+      assert json_response(conn, 200)["data"] == [group_res]
+    end
+  end
+
+  describe "create group" do
+    test "with valid attributes", %{conn: conn, user: user, actor: actor} do
+      conn = auth_conn(conn, user)
+      create_group_attrs = Map.put(@create_group_attrs, :actor_admin, actor.preferred_username)
+      conn = post(conn, group_path(conn, :create), group: create_group_attrs)
+
+      assert json_response(conn, 201)["username"] == @create_group_attrs.preferred_username
+    end
+  end
+
+  describe "join group" do
+    setup %{conn: conn} do
+      user = insert(:user)
+      actor = insert(:actor, user: user)
+      group = insert(:group, preferred_username: "mygroup")
+      {:ok, conn: conn, user: user, actor: actor, group: group}
+    end
+
+    test "from valid account", %{conn: conn, user: user, actor: actor, group: group} do
+      conn = auth_conn(conn, user)
+
+      conn =
+        post(conn, group_path(conn, :join, group.preferred_username), %{
+          "actor_name" => actor.preferred_username
+        })
+
+      resp = json_response(conn, 201)
+
+      assert resp = %{
+               "actor" => %{"username" => actor.preferred_username},
+               "group" => %{"username" => group.preferred_username},
+               "role" => 0
+             }
+    end
+  end
 end

test/eventos_web/controllers/follower_controller_test.exs

@@ -0,0 +1,76 @@
+defmodule EventosWeb.FollowerControllerTest do
+  use EventosWeb.ConnCase
+
+  alias Eventos.Actors
+  alias Eventos.Actors.Follower
+  import Eventos.Factory
+
+  @create_attrs %{approved: true, score: 42}
+  @update_attrs %{approved: false, score: 43}
+  @invalid_attrs %{approved: nil, score: nil}
+
+  setup %{conn: conn} do
+    actor = insert(:actor)
+    target_actor = insert(:actor)
+    follower = insert(:follower, actor: actor, target_actor: target_actor)
+
+    {:ok,
+     conn: put_req_header(conn, "accept", "application/json"),
+     actor: actor,
+     target_actor: target_actor,
+     follower: follower}
+  end
+
+  describe "create follower" do
+    test "renders follower when data is valid", %{
+      conn: conn,
+      actor: actor,
+      target_actor: target_actor
+    } do
+      create_attrs =
+        @create_attrs
+        |> Map.put(:actor_id, actor.id)
+        |> Map.put(:target_actor_id, target_actor.id)
+
+      conn = post(conn, follower_path(conn, :create), follower: create_attrs)
+      assert %{"id" => id} = json_response(conn, 201)["data"]
+
+      conn = get(conn, follower_path(conn, :show, id))
+      assert json_response(conn, 200)["data"] == %{"id" => id, "approved" => true, "score" => 42}
+    end
+
+    test "renders errors when data is invalid", %{conn: conn} do
+      conn = post(conn, follower_path(conn, :create), follower: @invalid_attrs)
+      assert json_response(conn, 422)["errors"] != %{}
+    end
+  end
+
+  describe "update follower" do
+    test "renders follower when data is valid", %{
+      conn: conn,
+      follower: %Follower{id: id} = follower
+    } do
+      conn = put(conn, follower_path(conn, :update, follower), follower: @update_attrs)
+      assert %{"id" => ^id} = json_response(conn, 200)["data"]
+
+      conn = get(conn, follower_path(conn, :show, id))
+      assert json_response(conn, 200)["data"] == %{"id" => id, "approved" => false, "score" => 43}
+    end
+
+    test "renders errors when data is invalid", %{conn: conn, follower: follower} do
+      conn = put(conn, follower_path(conn, :update, follower), follower: @invalid_attrs)
+      assert json_response(conn, 422)["errors"] != %{}
+    end
+  end
+
+  describe "delete follower" do
+    test "deletes chosen follower", %{conn: conn, follower: follower} do
+      conn = delete(conn, follower_path(conn, :delete, follower))
+      assert response(conn, 204)
+
+      assert_error_sent(404, fn ->
+        get(conn, follower_path(conn, :show, follower))
+      end)
+    end
+  end
+end

test/eventos_web/controllers/nodeinfo_controller_test.exs

@@ -0,0 +1,33 @@
+defmodule EventosWeb.NodeinfoControllerTest do
+  use EventosWeb.ConnCase
+
+  @instance Application.get_env(:eventos, :instance)
+
+  test "Get node info schemas", %{conn: conn} do
+    conn = get(conn, nodeinfo_path(conn, :schemas))
+
+    assert json_response(conn, 200) == %{
+             "links" => [
+               %{
+                 "href" => EventosWeb.Endpoint.url() <> "/nodeinfo/2.0.json",
+                 "rel" => "http://nodeinfo.diaspora.software/ns/schema/2.0"
+               }
+             ]
+           }
+  end
+
+  test "Get node info", %{conn: conn} do
+    conn = get(conn, nodeinfo_path(conn, :nodeinfo, "2.0.json"))
+
+    resp = json_response(conn, 200)
+
+    assert resp = %{
+             "metadata" => %{"nodeName" => Keyword.get(@instance, :name)},
+             "openRegistrations" => Keyword.get(@instance, :registrations_open),
+             "protocols" => ["activitypub"],
+             "services" => %{"inbound" => [], "outbound" => []},
+             "software" => %{"name" => "eventos", "version" => Keyword.get(@instance, :version)},
+             "version" => "2.0"
+           }
+  end
+end

test/support/factory.ex

@@ -24,11 +24,28 @@ defmodule Eventos.Factory do
       preferred_username: preferred_username,
       domain: nil,
       keys: pem,
+      type: :Person,
       url: EventosWeb.Endpoint.url() <> "/@#{preferred_username}",
       user: nil
     }
   end
 
+  def group_factory do
+    struct!(
+      actor_factory(),
+      %{
+        type: :Group
+      }
+    )
+  end
+
+  def follower_factory do
+    %Eventos.Actors.Follower{
+      target_actor: build(:actor),
+      actor: build(:actor)
+    }
+  end
+
   def category_factory do
     %Eventos.Events.Category{
       title: sequence("MyCategory"),