Introduce follower, add tests

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

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