Move to GraphQL

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

test/mobilizon/actors/actors_test.exs

@@ -0,0 +1,635 @@
+defmodule Mobilizon.ActorsTest do
+  use Mobilizon.DataCase
+  import Mobilizon.Factory
+
+  alias Mobilizon.Actors
+
+  describe "actors" do
+    alias Mobilizon.Actors.Actor
+
+    @valid_attrs %{
+      summary: "some description",
+      name: "Bobby Blank",
+      domain: "some domain",
+      keys: "some keypair",
+      suspended: true,
+      uri: "some uri",
+      url: "some url",
+      preferred_username: "some username"
+    }
+    @update_attrs %{
+      summary: "some updated description",
+      name: "some updated name",
+      domain: "some updated domain",
+      keys: "some updated keys",
+      suspended: false,
+      uri: "some updated uri",
+      url: "some updated url",
+      preferred_username: "some updated username"
+    }
+    @invalid_attrs %{
+      summary: nil,
+      name: nil,
+      domain: nil,
+      keys: nil,
+      suspended: nil,
+      uri: nil,
+      url: nil,
+      preferred_username: nil
+    }
+
+    @remote_account_url "https://social.tcit.fr/users/tcit"
+    @remote_account_username "tcit"
+    @remote_account_domain "social.tcit.fr"
+
+    setup do
+      user = insert(:user)
+      actor = insert(:actor, user: user)
+
+      {:ok, actor: actor}
+    end
+
+    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", %{actor: actor} do
+      actor_fetched = Actors.get_actor!(actor.id)
+      assert actor_fetched = actor
+    end
+
+    test "get_actor_for_user/1 returns the actor for an user", %{actor: %{user: user} = actor} do
+      assert actor = Actors.get_actor_for_user(user)
+    end
+
+    test "get_actor_for_user/1 returns the actor for an user with no default actor defined" do
+      user = insert(:user)
+      actor = insert(:actor, user: user)
+      assert actor = Actors.get_actor_for_user(user)
+    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 "get_actor_by_name/1 returns a local actor", %{actor: actor} do
+      actor_found = Actors.get_actor_by_name(actor.preferred_username)
+      assert actor_found = actor
+    end
+
+    test "get_actor_by_name/1 returns a remote actor" do
+      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
+
+    test "get_local_actor_by_name_with_everything!/1 returns the local actor with it's organized events",
+         %{
+           actor: actor
+         } do
+      assert Actors.get_local_actor_by_name_with_everything(actor.preferred_username).organized_events ==
+               []
+
+      event = insert(:event, organizer_actor: actor)
+
+      events =
+        Actors.get_local_actor_by_name_with_everything(actor.preferred_username).organized_events
+
+      assert events = [event]
+    end
+
+    test "get_actor_by_name_with_everything!/1 returns the local actor with it's organized events",
+         %{
+           actor: actor
+         } do
+      assert Actors.get_actor_by_name_with_everything(actor.preferred_username).organized_events ==
+               []
+
+      event = insert(:event, organizer_actor: actor)
+      events = Actors.get_actor_by_name_with_everything(actor.preferred_username).organized_events
+      assert events = [event]
+    end
+
+    test "get_actor_by_name_with_everything!/1 returns the remote actor with it's organized events" do
+      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}"
+             ).organized_events == []
+
+      event = insert(:event, organizer_actor: actor)
+
+      events =
+        Actors.get_actor_by_name_with_everything("#{actor.preferred_username}@#{actor.domain}").organized_events
+
+      assert events = [event]
+    end
+
+    test "get_or_fetch_by_url/1 returns the local actor for the url", %{
+      actor: actor
+    } do
+      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 {:ok,
+              %Actor{preferred_username: @remote_account_username, domain: @remote_account_domain}} =
+               Actors.get_or_fetch_by_url(@remote_account_url)
+    end
+
+    test "test find_local_by_username/1 returns local actors with similar usernames", %{
+      actor: actor
+    } do
+      actor2 = insert(:actor)
+      actors = Actors.find_local_by_username("thomas")
+      assert actors = [actor, actor2]
+    end
+
+    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
+
+    test "test search/1 returns accounts for search with non existent accounts" do
+      assert {:ok, []} = Actors.search("nonexistent")
+    end
+
+    test "test search/1 returns accounts for search with existing remote accounts" do
+      assert {:ok, [%Actor{preferred_username: "tcit", domain: "framapiaf.org"}]} =
+               Actors.search("tcit@framapiaf.org")
+    end
+
+    test "test search/1 returns accounts for search with non existent remote accounts" do
+      assert {:error, _} = Actors.search("tcit@yolo.tld")
+    end
+
+    test "test get_public_key_for_url/1 with local actor", %{actor: actor} do
+      assert Actor.get_public_key_for_url(actor.url) ==
+               actor.keys |> Mobilizon.Service.ActivityPub.Utils.pem_to_public_key()
+    end
+
+    @remote_actor_key {:RSAPublicKey,
+                       20_890_513_599_005_517_665_557_846_902_571_022_168_782_075_040_010_449_365_706_450_877_170_130_373_892_202_874_869_873_999_284_399_697_282_332_064_948_148_602_583_340_776_692_090_472_558_740_998_357_203_838_580_321_412_679_020_304_645_826_371_196_718_081_108_049_114_160_630_664_514_340_729_769_453_281_682_773_898_619_827_376_232_969_899_348_462_205_389_310_883_299_183_817_817_999_273_916_446_620_095_414_233_374_619_948_098_516_821_650_069_821_783_810_210_582_035_456_563_335_930_330_252_551_528_035_801_173_640_288_329_718_719_895_926_309_416_142_129_926_226_047_930_429_802_084_560_488_897_717_417_403_272_782_469_039_131_379_953_278_833_320_195_233_761_955_815_307_522_871_787_339_192_744_439_894_317_730_207_141_881_699_363_391_788_150_650_217_284_777_541_358_381_165_360_697_136_307_663_640_904_621_178_632_289_787,
+                       65537}
+    test "test get_public_key_for_url/1 with remote actor" do
+      assert Actor.get_public_key_for_url(@remote_account_url) == @remote_actor_key
+    end
+
+    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 == "Bobby Blank"
+      assert actor.domain == "some domain"
+      assert actor.keys == "some keypair"
+      assert actor.suspended
+      assert actor.preferred_username == "some username"
+    end
+
+    test "create_actor/1 with empty data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Actors.create_actor()
+    end
+
+    test "create_actor/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Actors.create_actor(@invalid_attrs)
+    end
+
+    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"
+      assert actor.name == "some updated name"
+      assert actor.domain == "some updated domain"
+      assert actor.keys == "some updated keys"
+      refute actor.suspended
+      assert actor.preferred_username == "some updated username"
+    end
+
+    test "update_actor/2 with invalid data returns error changeset", %{actor: actor} do
+      assert {:error, %Ecto.Changeset{}} = Actors.update_actor(actor, @invalid_attrs)
+      actor_fetched = Actors.get_actor!(actor.id)
+      assert actor = actor_fetched
+    end
+
+    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", %{actor: actor} do
+      assert %Ecto.Changeset{} = Actors.change_actor(actor)
+    end
+  end
+
+  describe "users" do
+    alias Mobilizon.Actors.{User, Actor}
+
+    @actor_valid_attrs %{
+      description: "some description",
+      display_name: "some display_name",
+      domain: "some domain",
+      keys: "some keys",
+      suspended: true,
+      uri: "some uri",
+      url: "some url",
+      preferred_username: "some username"
+    }
+    @valid_attrs %{email: "foo@bar.tld", password: "some password", role: 42}
+    @update_attrs %{email: "foo@fighters.tld", password: "some updated password", role: 43}
+    @invalid_attrs %{email: nil, password_hash: nil, role: nil}
+
+    def user_fixture(attrs \\ %{}) do
+      insert(:user)
+    end
+
+    test "list_users/0 returns all users" do
+      user = user_fixture()
+      users = Actors.list_users()
+      assert users = [user]
+    end
+
+    test "get_user!/1 returns the user with given id" do
+      user = user_fixture()
+      assert user = Actors.get_user!(user.id)
+    end
+
+    test "create_user/1 with valid data creates a user" do
+      {:ok, %Actor{} = actor} = Actors.create_actor(@actor_valid_attrs)
+      attrs = @valid_attrs |> Map.put(:actor_id, actor.id) |> Map.put(:default_actor_id, actor.id)
+      assert {:ok, %User{} = user} = Actors.create_user(attrs)
+      assert user.email == "foo@bar.tld"
+      assert user.role == 42
+    end
+
+    test "create_user/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Actors.create_user(@invalid_attrs)
+    end
+
+    test "update_user/2 with valid data updates the user" do
+      user = user_fixture()
+      assert {:ok, user} = Actors.update_user(user, @update_attrs)
+      assert %User{} = user
+      assert user.email == "foo@fighters.tld"
+      assert user.role == 43
+    end
+
+    test "update_user/2 with invalid data returns error changeset" do
+      user = user_fixture()
+      assert {:error, %Ecto.Changeset{}} = Actors.update_user(user, @invalid_attrs)
+      assert user = Actors.get_user!(user.id)
+    end
+
+    test "delete_user/1 deletes the user" do
+      user = user_fixture()
+      assert {:ok, %User{}} = Actors.delete_user(user)
+      assert_raise Ecto.NoResultsError, fn -> Actors.get_user!(user.id) end
+    end
+
+    test "change_user/1 returns a user changeset" do
+      user = user_fixture()
+      assert %Ecto.Changeset{} = Actors.change_user(user)
+    end
+
+    @email "email@domain.tld"
+    @password "password"
+    test "authenticate/1 checks the user's password" do
+      {:ok, %Actor{user: user} = _actor} =
+        Actors.register(%{email: @email, password: @password, username: "yolo"})
+
+      assert {:ok, _, _} = Actors.authenticate(%{user: user, password: @password})
+
+      assert {:error, :unauthorized} ==
+               Actors.authenticate(%{user: user, password: "bad password"})
+    end
+
+    test "get_user_by_email/1 finds an user by it's email" do
+      {:ok, %Actor{user: %User{email: email} = user} = _actor} =
+        Actors.register(%{email: @email, password: @password, username: "yolo"})
+
+      assert email == @email
+      {:ok, %User{id: id}} = Actors.get_user_by_email(@email)
+      assert id == user.id
+      assert {:error, :user_not_found} = Actors.get_user_by_email("no email")
+    end
+
+    test "get_user_by_email/1 finds an activated user by it's email" do
+      {:ok, %Actor{user: %User{email: email} = user} = _actor} =
+        Actors.register(%{email: @email, password: @password, username: "yolo"})
+      {:ok, %User{id: id}} = Actors.get_user_by_email(@email, false)
+      assert id == user.id
+      assert {:error, :user_not_found} = Actors.get_user_by_email(@email, true)
+
+      Actors.update_user(user, %{
+          "confirmed_at" => DateTime.utc_now(),
+          "confirmation_sent_at" => nil,
+          "confirmation_token" => nil
+      })
+
+      assert {:error, :user_not_found} = Actors.get_user_by_email(@email, false)
+      {:ok, %User{id: id}} = Actors.get_user_by_email(@email, true)
+      assert id == user.id
+    end
+  end
+
+  describe "groups" do
+    alias Mobilizon.Actors
+    alias Mobilizon.Actors.Actor
+
+    @valid_attrs %{
+      summary: "some description",
+      suspended: true,
+      preferred_username: "some-title",
+      name: "Some Title"
+    }
+    @update_attrs %{
+      summary: "some updated description",
+      suspended: false,
+      preferred_username: "some-updated-title",
+      name: "Some Updated Title"
+    }
+    @invalid_attrs %{summary: nil, suspended: nil, preferred_username: nil, name: nil}
+
+    test "create_group/1 with valid data creates a group" do
+      assert {:ok, %Actor{} = group} = Actors.create_group(@valid_attrs)
+      assert group.summary == "some description"
+      refute group.suspended
+      assert group.preferred_username == "some-title"
+    end
+
+    test "create_group/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Actors.create_group(@invalid_attrs)
+    end
+  end
+
+  alias Mobilizon.Actors
+
+  describe "bots" do
+    alias Mobilizon.Actors.Bot
+
+    @valid_attrs %{source: "some source", type: "some type"}
+    @update_attrs %{source: "some updated source", type: "some updated type"}
+    @invalid_attrs %{source: nil, type: nil}
+
+    def bot_fixture(attrs \\ %{}) do
+      insert(:bot)
+    end
+
+    test "list_bots/0 returns all bots" do
+      bot = bot_fixture()
+      bots = Actors.list_bots()
+      assert bots = [bot]
+    end
+
+    test "get_bot!/1 returns the bot with given id" do
+      bot = bot_fixture()
+      assert bot = Actors.get_bot!(bot.id)
+    end
+
+    test "create_bot/1 with valid data creates a bot" do
+      attrs =
+        @valid_attrs
+        |> Map.merge(%{actor_id: insert(:actor).id})
+        |> Map.merge(%{user_id: insert(:user).id})
+
+      assert {:ok, %Bot{} = bot} = Actors.create_bot(attrs)
+      assert bot.source == "some source"
+      assert bot.type == "some type"
+    end
+
+    test "create_bot/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Actors.create_bot(@invalid_attrs)
+    end
+
+    test "update_bot/2 with valid data updates the bot" do
+      bot = bot_fixture()
+      assert {:ok, bot} = Actors.update_bot(bot, @update_attrs)
+      assert %Bot{} = bot
+      assert bot.source == "some updated source"
+      assert bot.type == "some updated type"
+    end
+
+    test "update_bot/2 with invalid data returns error changeset" do
+      bot = bot_fixture()
+      assert {:error, %Ecto.Changeset{}} = Actors.update_bot(bot, @invalid_attrs)
+      assert bot = Actors.get_bot!(bot.id)
+    end
+
+    test "delete_bot/1 deletes the bot" do
+      bot = bot_fixture()
+      assert {:ok, %Bot{}} = Actors.delete_bot(bot)
+      assert_raise Ecto.NoResultsError, fn -> Actors.get_bot!(bot.id) end
+    end
+
+    test "change_bot/1 returns a bot changeset" do
+      bot = bot_fixture()
+      assert %Ecto.Changeset{} = Actors.change_bot(bot)
+    end
+  end
+
+  describe "followers" do
+    alias Mobilizon.Actors.Follower
+    alias Mobilizon.Actors.Actor
+
+    @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)
+      {:ok, actor: actor, target_actor: target_actor}
+    end
+
+    defp create_follower(%{actor: actor, target_actor: target_actor}) do
+      insert(:follower, actor: actor, target_actor: target_actor)
+    end
+
+    test "get_follower!/1 returns the follower with given id", context do
+      follower = create_follower(context)
+      assert follower = Actors.get_follower!(follower.id)
+    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
+
+      assert [target_actor] = Actor.get_followings(actor)
+      assert [actor] = Actor.get_followers(target_actor)
+    end
+
+    test "create_follower/1 with valid data but same actors fails to create a follower", %{
+      actor: actor,
+      target_actor: target_actor
+    } do
+      create_follower(%{actor: actor, target_actor: target_actor})
+
+      valid_attrs =
+        @valid_attrs
+        |> Map.put(:actor_id, actor.id)
+        |> Map.put(:target_actor_id, target_actor.id)
+
+      assert {:error, _follower} = Actors.create_follower(valid_attrs)
+    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", context do
+      follower = create_follower(context)
+      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", context do
+      follower = create_follower(context)
+      assert {:error, %Ecto.Changeset{}} = Actors.update_follower(follower, @invalid_attrs)
+      assert follower = Actors.get_follower!(follower.id)
+    end
+
+    test "delete_follower/1 deletes the follower", context do
+      follower = create_follower(context)
+      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", context do
+      follower = create_follower(context)
+      assert %Ecto.Changeset{} = Actors.change_follower(follower)
+    end
+  end
+
+  describe "members" do
+    alias Mobilizon.Actors.Member
+    alias Mobilizon.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/mobilizon/addresses/addresses_test.exs

@@ -0,0 +1,104 @@
+defmodule Mobilizon.AddressesTest do
+  use Mobilizon.DataCase
+
+  alias Mobilizon.Addresses
+
+  describe "addresses" do
+    alias Mobilizon.Addresses.Address
+
+    @valid_attrs %{
+      addressCountry: "some addressCountry",
+      addressLocality: "some addressLocality",
+      addressRegion: "some addressRegion",
+      description: "some description",
+      floor: "some floor",
+      postalCode: "some postalCode",
+      streetAddress: "some streetAddress",
+      geom: %Geo.Point{coordinates: {10, -10}, srid: 4326}
+    }
+    @update_attrs %{
+      addressCountry: "some updated addressCountry",
+      addressLocality: "some updated addressLocality",
+      addressRegion: "some updated addressRegion",
+      description: "some updated description",
+      floor: "some updated floor",
+      postalCode: "some updated postalCode",
+      streetAddress: "some updated streetAddress",
+      geom: %Geo.Point{coordinates: {20, -20}, srid: 4326}
+    }
+    @invalid_attrs %{
+      addressCountry: nil,
+      addressLocality: nil,
+      addressRegion: nil,
+      description: nil,
+      floor: nil,
+      postalCode: nil,
+      streetAddress: nil,
+      geom: nil
+    }
+
+    def address_fixture(attrs \\ %{}) do
+      {:ok, address} =
+        attrs
+        |> Enum.into(@valid_attrs)
+        |> Addresses.create_address()
+
+      address
+    end
+
+    test "list_addresses/0 returns all addresses" do
+      address = address_fixture()
+      assert Addresses.list_addresses() == [address]
+    end
+
+    test "get_address!/1 returns the address with given id" do
+      address = address_fixture()
+      assert Addresses.get_address!(address.id) == address
+    end
+
+    test "create_address/1 with valid data creates a address" do
+      assert {:ok, %Address{} = address} = Addresses.create_address(@valid_attrs)
+      assert address.addressCountry == "some addressCountry"
+      assert address.addressLocality == "some addressLocality"
+      assert address.addressRegion == "some addressRegion"
+      assert address.description == "some description"
+      assert address.floor == "some floor"
+      assert address.postalCode == "some postalCode"
+      assert address.streetAddress == "some streetAddress"
+    end
+
+    test "update_address/2 with valid data updates the address" do
+      address = address_fixture()
+      assert {:ok, address} = Addresses.update_address(address, @update_attrs)
+      assert %Address{} = address
+      assert address.addressCountry == "some updated addressCountry"
+      assert address.addressLocality == "some updated addressLocality"
+      assert address.addressRegion == "some updated addressRegion"
+      assert address.description == "some updated description"
+      assert address.floor == "some updated floor"
+      assert address.postalCode == "some updated postalCode"
+      assert address.streetAddress == "some updated streetAddress"
+    end
+
+    test "delete_address/1 deletes the address" do
+      address = address_fixture()
+      assert {:ok, %Address{}} = Addresses.delete_address(address)
+      assert_raise Ecto.NoResultsError, fn -> Addresses.get_address!(address.id) end
+    end
+
+    test "change_address/1 returns a address changeset" do
+      address = address_fixture()
+      assert %Ecto.Changeset{} = Addresses.change_address(address)
+    end
+
+    test "process_geom/2 with valid data returns a Point element" do
+      attrs = %{"type" => "point", "data" => %{"latitude" => 10, "longitude" => -10}}
+      assert {:ok, %Geo.Point{}} = Addresses.process_geom(attrs)
+    end
+
+    test "process_geom/2 with invalid data returns nil" do
+      attrs = %{"type" => :point, "data" => %{"latitude" => nil, "longitude" => nil}}
+      assert {:error, "Latitude and longitude must be numbers"} = Addresses.process_geom(attrs)
+    end
+  end
+end

test/mobilizon/events/events_test.exs

@@ -0,0 +1,599 @@
+defmodule Mobilizon.EventsTest do
+  use Mobilizon.DataCase
+
+  import Mobilizon.Factory
+
+  alias Mobilizon.Events
+  alias Mobilizon.Actors
+
+  @event_valid_attrs %{
+    begins_on: "2010-04-17 14:00:00.000000Z",
+    description: "some description",
+    ends_on: "2010-04-17 14:00:00.000000Z",
+    title: "some title"
+  }
+
+  def actor_fixture do
+    insert(:actor)
+  end
+
+  def address_fixture do
+    insert(:address)
+  end
+
+  def event_fixture do
+    insert(:event)
+  end
+
+  def category_fixture do
+    insert(:category)
+  end
+
+  describe "events" do
+    alias Mobilizon.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",
+      ends_on: "2010-04-17 14:00:00.000000Z",
+      title: "some title"
+    }
+    @update_attrs %{
+      begins_on: "2011-05-18 15:01:01.000000Z",
+      description: "some updated description",
+      ends_on: "2011-05-18 15:01:01.000000Z",
+      title: "some updated title"
+    }
+    @invalid_attrs %{begins_on: nil, description: nil, ends_on: nil, title: nil}
+
+    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", %{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{title: title} = event
+    } do
+      assert title == hd(Events.find_events_by_name(event.title)).title
+
+      %Event{title: title2} = event2 = insert(:event, title: "Special event")
+      assert event2.title == hd(Events.find_events_by_name("Special")).title
+
+      assert event2.title == hd(Events.find_events_by_name("  Special  ")).title
+
+      assert title = hd(Events.find_events_by_name("")).title
+      assert title2 = hd(tl(Events.find_events_by_name(""))).title
+    end
+
+    test "create_event/1 with valid data creates a event" do
+      actor = actor_fixture()
+      category = category_fixture()
+      address = address_fixture()
+
+      valid_attrs =
+        @event_valid_attrs
+        |> Map.put(:organizer_actor, actor)
+        |> Map.put(:organizer_actor_id, actor.id)
+        |> Map.put(:category_id, category.id)
+        |> Map.put(:address_id, address.id)
+
+      assert {:ok, %Event{} = event} = Events.create_event(valid_attrs)
+      assert event.begins_on == DateTime.from_naive!(~N[2010-04-17 14:00:00.000000Z], "Etc/UTC")
+      assert event.description == "some description"
+      assert event.ends_on == DateTime.from_naive!(~N[2010-04-17 14:00:00.000000Z], "Etc/UTC")
+      assert event.title == "some title"
+    end
+
+    test "create_event/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Events.create_event(@invalid_attrs)
+    end
+
+    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")
+      assert event.description == "some updated description"
+      assert event.ends_on == DateTime.from_naive!(~N[2011-05-18 15:01:01.000000Z], "Etc/UTC")
+      assert event.title == "some updated title"
+    end
+
+    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", %{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", %{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
+
+    test "get_event_by_url/1 with valid url", %{actor: actor, event: event} do
+      assert event = Events.get_event_by_url(event.url)
+    end
+
+    test "get_event_by_url/1 with bad url", %{actor: actor, event: event} do
+      refute event == Events.get_event_by_url("not valid")
+    end
+
+    test "get_event_by_url!/1 with valid url", %{actor: actor, event: event} do
+      assert event = Events.get_event_by_url!(event.url)
+    end
+
+    test "get_event_by_url!/1 with bad url", %{actor: actor, event: event} do
+      assert_raise Ecto.NoResultsError, fn ->
+        Events.get_event_by_url!("not valid")
+      end
+    end
+  end
+
+  describe "categories" do
+    alias Mobilizon.Events.Category
+
+    setup do
+      category = insert(:category)
+      {:ok, category: category}
+    end
+
+    @valid_attrs %{
+      description: "some description",
+      picture: %Plug.Upload{
+        path: "test/fixtures/category_picture.png",
+        filename: "category_picture.png"
+      },
+      title: "some title"
+    }
+    @update_attrs %{
+      description: "some updated description",
+      picture: %Plug.Upload{
+        path: "test/fixtures/category_picture_updated.png",
+        filename: "category_picture_updated.png"
+      },
+      title: "some updated title"
+    }
+    @invalid_attrs %{description: nil, picture: nil, title: nil}
+
+    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", %{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"
+      assert category.picture.file_name == @valid_attrs.picture.filename
+      assert category.title == "some title"
+    end
+
+    test "create_category/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Events.create_category(@invalid_attrs)
+    end
+
+    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"
+      assert category.picture.file_name == @update_attrs.picture.filename
+      assert category.title == "some updated title"
+    end
+
+    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", %{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", %{category: category} do
+      assert %Ecto.Changeset{} = Events.change_category(category)
+    end
+  end
+
+  describe "tags" do
+    alias Mobilizon.Events.Tag
+
+    @valid_attrs %{title: "some title"}
+    @update_attrs %{title: "some updated title"}
+    @invalid_attrs %{title: nil}
+
+    def tag_fixture(attrs \\ %{}) do
+      {:ok, tag} =
+        attrs
+        |> Enum.into(@valid_attrs)
+        |> Events.create_tag()
+
+      tag
+    end
+
+    test "list_tags/0 returns all tags" do
+      tag = tag_fixture()
+      assert Events.list_tags() == [tag]
+    end
+
+    test "get_tag!/1 returns the tag with given id" do
+      tag = tag_fixture()
+      assert Events.get_tag!(tag.id) == tag
+    end
+
+    test "create_tag/1 with valid data creates a tag" do
+      assert {:ok, %Tag{} = tag} = Events.create_tag(@valid_attrs)
+      assert tag.title == "some title"
+    end
+
+    test "create_tag/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Events.create_tag(@invalid_attrs)
+    end
+
+    test "update_tag/2 with valid data updates the tag" do
+      tag = tag_fixture()
+      assert {:ok, tag} = Events.update_tag(tag, @update_attrs)
+      assert %Tag{} = tag
+      assert tag.title == "some updated title"
+    end
+
+    test "update_tag/2 with invalid data returns error changeset" do
+      tag = tag_fixture()
+      assert {:error, %Ecto.Changeset{}} = Events.update_tag(tag, @invalid_attrs)
+      assert tag == Events.get_tag!(tag.id)
+    end
+
+    test "delete_tag/1 deletes the tag" do
+      tag = tag_fixture()
+      assert {:ok, %Tag{}} = Events.delete_tag(tag)
+      assert_raise Ecto.NoResultsError, fn -> Events.get_tag!(tag.id) end
+    end
+
+    test "change_tag/1 returns a tag changeset" do
+      tag = tag_fixture()
+      assert %Ecto.Changeset{} = Events.change_tag(tag)
+    end
+  end
+
+  describe "participants" do
+    alias Mobilizon.Events.{Participant, Event}
+    alias Mobilizon.Actors.Actor
+
+    @valid_attrs %{role: 42}
+    @update_attrs %{role: 43}
+    @invalid_attrs %{role: nil}
+
+    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", %{participant: participant} do
+      assert [%Participant{} = participant] = Events.list_participants()
+    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()
+      event = event_fixture()
+      valid_attrs = Map.put(@valid_attrs, :event_id, event.id)
+      valid_attrs = Map.put(valid_attrs, :actor_id, actor.id)
+      assert {:ok, %Participant{} = participant} = Events.create_participant(valid_attrs)
+      assert participant.role == 42
+    end
+
+    test "create_participant/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Events.create_participant(@invalid_attrs)
+    end
+
+    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", %{
+      participant: participant
+    } do
+      assert {:error, %Ecto.Changeset{}} = Events.update_participant(participant, @invalid_attrs)
+    end
+
+    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", %{participant: participant} do
+      assert %Ecto.Changeset{} = Events.change_participant(participant)
+    end
+  end
+
+  describe "sessions" do
+    alias Mobilizon.Events.Session
+
+    @valid_attrs %{
+      audios_urls: "some audios_urls",
+      language: "some language",
+      long_abstract: "some long_abstract",
+      short_abstract: "some short_abstract",
+      slides_url: "some slides_url",
+      subtitle: "some subtitle",
+      title: "some title",
+      videos_urls: "some videos_urls"
+    }
+    @update_attrs %{
+      audios_urls: "some updated audios_urls",
+      language: "some updated language",
+      long_abstract: "some updated long_abstract",
+      short_abstract: "some updated short_abstract",
+      slides_url: "some updated slides_url",
+      subtitle: "some updated subtitle",
+      title: "some updated title",
+      videos_urls: "some updated videos_urls"
+    }
+    @invalid_attrs %{
+      audios_urls: nil,
+      language: nil,
+      long_abstract: nil,
+      short_abstract: nil,
+      slides_url: nil,
+      subtitle: nil,
+      title: nil,
+      videos_urls: nil
+    }
+
+    def session_fixture(attrs \\ %{}) do
+      event = event_fixture()
+      valid_attrs = Map.put(@valid_attrs, :event_id, event.id)
+
+      {:ok, session} =
+        attrs
+        |> Enum.into(valid_attrs)
+        |> Events.create_session()
+
+      session
+    end
+
+    test "list_sessions/0 returns all sessions" do
+      session = session_fixture()
+      assert Events.list_sessions() == [session]
+    end
+
+    test "get_session!/1 returns the session with given id" do
+      session = session_fixture()
+      assert Events.get_session!(session.id) == session
+    end
+
+    test "create_session/1 with valid data creates a session" do
+      event = event_fixture()
+      valid_attrs = Map.put(@valid_attrs, :event_id, event.id)
+      assert {:ok, %Session{} = session} = Events.create_session(valid_attrs)
+      assert session.audios_urls == "some audios_urls"
+      assert session.language == "some language"
+      assert session.long_abstract == "some long_abstract"
+      assert session.short_abstract == "some short_abstract"
+      assert session.slides_url == "some slides_url"
+      assert session.subtitle == "some subtitle"
+      assert session.title == "some title"
+      assert session.videos_urls == "some videos_urls"
+    end
+
+    test "create_session/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Events.create_session(@invalid_attrs)
+    end
+
+    test "update_session/2 with valid data updates the session" do
+      session = session_fixture()
+      assert {:ok, session} = Events.update_session(session, @update_attrs)
+      assert %Session{} = session
+      assert session.audios_urls == "some updated audios_urls"
+      assert session.language == "some updated language"
+      assert session.long_abstract == "some updated long_abstract"
+      assert session.short_abstract == "some updated short_abstract"
+      assert session.slides_url == "some updated slides_url"
+      assert session.subtitle == "some updated subtitle"
+      assert session.title == "some updated title"
+      assert session.videos_urls == "some updated videos_urls"
+    end
+
+    test "update_session/2 with invalid data returns error changeset" do
+      session = session_fixture()
+      assert {:error, %Ecto.Changeset{}} = Events.update_session(session, @invalid_attrs)
+      assert session == Events.get_session!(session.id)
+    end
+
+    test "delete_session/1 deletes the session" do
+      session = session_fixture()
+      assert {:ok, %Session{}} = Events.delete_session(session)
+      assert_raise Ecto.NoResultsError, fn -> Events.get_session!(session.id) end
+    end
+
+    test "change_session/1 returns a session changeset" do
+      session = session_fixture()
+      assert %Ecto.Changeset{} = Events.change_session(session)
+    end
+  end
+
+  describe "tracks" do
+    alias Mobilizon.Events.Track
+
+    @valid_attrs %{color: "some color", description: "some description", name: "some name"}
+    @update_attrs %{
+      color: "some updated color",
+      description: "some updated description",
+      name: "some updated name"
+    }
+    @invalid_attrs %{color: nil, description: nil, name: nil}
+
+    def track_fixture(attrs \\ %{}) do
+      event = event_fixture()
+      valid_attrs = Map.put(@valid_attrs, :event_id, event.id)
+
+      {:ok, track} =
+        attrs
+        |> Enum.into(valid_attrs)
+        |> Events.create_track()
+
+      track
+    end
+
+    test "list_tracks/0 returns all tracks" do
+      track = track_fixture()
+      assert Events.list_tracks() == [track]
+    end
+
+    test "get_track!/1 returns the track with given id" do
+      track = track_fixture()
+      assert Events.get_track!(track.id) == track
+    end
+
+    test "create_track/1 with valid data creates a track" do
+      event = event_fixture()
+      valid_attrs = Map.put(@valid_attrs, :event_id, event.id)
+      assert {:ok, %Track{} = track} = Events.create_track(valid_attrs)
+      assert track.color == "some color"
+      assert track.description == "some description"
+      assert track.name == "some name"
+    end
+
+    test "create_track/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Events.create_track(@invalid_attrs)
+    end
+
+    test "update_track/2 with valid data updates the track" do
+      track = track_fixture()
+      assert {:ok, track} = Events.update_track(track, @update_attrs)
+      assert %Track{} = track
+      assert track.color == "some updated color"
+      assert track.description == "some updated description"
+      assert track.name == "some updated name"
+    end
+
+    test "update_track/2 with invalid data returns error changeset" do
+      track = track_fixture()
+      assert {:error, %Ecto.Changeset{}} = Events.update_track(track, @invalid_attrs)
+      assert track == Events.get_track!(track.id)
+    end
+
+    test "delete_track/1 deletes the track" do
+      track = track_fixture()
+      assert {:ok, %Track{}} = Events.delete_track(track)
+      assert_raise Ecto.NoResultsError, fn -> Events.get_track!(track.id) end
+    end
+
+    test "change_track/1 returns a track changeset" do
+      track = track_fixture()
+      assert %Ecto.Changeset{} = Events.change_track(track)
+    end
+  end
+
+  describe "comments" do
+    alias Mobilizon.Events.Comment
+
+    @valid_attrs %{text: "some text"}
+    @update_attrs %{text: "some updated text"}
+    @invalid_attrs %{text: nil, url: nil}
+
+    def comment_fixture() do
+      insert(:comment)
+    end
+
+    test "list_comments/0 returns all comments" do
+      comment = comment_fixture()
+      comments = Events.list_comments()
+      assert comments = [comment]
+    end
+
+    test "get_comment!/1 returns the comment with given id" do
+      comment = comment_fixture()
+      comment_fetched = Events.get_comment!(comment.id)
+      assert comment_fetched = comment
+    end
+
+    test "create_comment/1 with valid data creates a comment" do
+      actor = actor_fixture()
+      comment_data = Map.merge(@valid_attrs, %{actor_id: actor.id})
+      assert {:ok, %Comment{} = comment} = Events.create_comment(comment_data)
+      assert comment.text == "some text"
+      assert comment.actor_id == actor.id
+    end
+
+    test "create_comment/1 with invalid data returns error changeset" do
+      assert {:error, %Ecto.Changeset{}} = Events.create_comment(@invalid_attrs)
+    end
+
+    test "update_comment/2 with valid data updates the comment" do
+      comment = comment_fixture()
+      assert {:ok, comment} = Events.update_comment(comment, @update_attrs)
+      assert %Comment{} = comment
+      assert comment.text == "some updated text"
+    end
+
+    test "update_comment/2 with invalid data returns error changeset" do
+      comment = comment_fixture()
+      assert {:error, %Ecto.Changeset{}} = Events.update_comment(comment, @invalid_attrs)
+      comment_fetched = Events.get_comment!(comment.id)
+      assert comment = comment_fetched
+    end
+
+    test "delete_comment/1 deletes the comment" do
+      comment = comment_fixture()
+      assert {:ok, %Comment{}} = Events.delete_comment(comment)
+      assert_raise Ecto.NoResultsError, fn -> Events.get_comment!(comment.id) end
+    end
+
+    test "change_comment/1 returns a comment changeset" do
+      comment = comment_fixture()
+      assert %Ecto.Changeset{} = Events.change_comment(comment)
+    end
+  end
+end

test/mobilizon/service/activitypub/activitypub_test.exs

@@ -0,0 +1,99 @@
+defmodule Mobilizon.Service.Activitypub.ActivitypubTest do
+  use Mobilizon.DataCase
+
+  import Mobilizon.Factory
+
+  alias Mobilizon.Events
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Actors
+  alias Mobilizon.Service.ActivityPub
+  alias Mobilizon.Activity
+
+  describe "fetching actor from it's url" 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
+    test "removes doubled 'to' recipients" do
+      actor = insert(:actor)
+
+      {:ok, activity} =
+        ActivityPub.create(%{
+          to: ["user1", "user1", "user2"],
+          actor: actor,
+          context: "",
+          object: %{}
+        })
+
+      assert activity.data["to"] == ["user1", "user2"]
+      assert activity.actor == actor.url
+      assert activity.recipients == ["user1", "user2"]
+    end
+  end
+
+  describe "fetching an" do
+    test "event by url" do
+      {:ok, object} =
+        ActivityPub.fetch_event_from_url("https://social.tcit.fr/@tcit/99908779444618462")
+
+      {:ok, object_again} =
+        ActivityPub.fetch_event_from_url("https://social.tcit.fr/@tcit/99908779444618462")
+
+      assert object == object_again
+    end
+  end
+
+  describe "deletion" do
+    test "it creates a delete activity and deletes the original event" do
+      event = insert(:event)
+      event = Events.get_event_full_by_url!(event.url)
+      {:ok, delete} = ActivityPub.delete(event)
+
+      assert delete.data["type"] == "Delete"
+      assert delete.data["actor"] == event.organizer_actor.url
+      assert delete.data["object"] == event.url
+
+      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
+
+  describe "update" do
+    test "it creates an update activity with the new actor data" do
+      actor = insert(:actor)
+      actor_data = MobilizonWeb.ActivityPub.ActorView.render("actor.json", %{actor: actor})
+
+      {:ok, update} =
+        ActivityPub.update(%{
+          actor: actor_data["url"],
+          to: [actor.url <> "/followers"],
+          cc: [],
+          object: actor_data
+        })
+
+      assert update.data["actor"] == actor.url
+      assert update.data["to"] == [actor.url <> "/followers"]
+      assert update.data["object"]["id"] == actor_data["id"]
+      assert update.data["object"]["type"] == actor_data["type"]
+    end
+  end
+end

test/mobilizon/service/web_finger/web_finger_test.exs

@@ -0,0 +1,69 @@
+defmodule Mobilizon.Service.WebFingerTest do
+  use Mobilizon.DataCase
+  alias Mobilizon.Service.WebFinger
+  import Mobilizon.Factory
+
+  describe "host meta" do
+    test "returns a link to the xml lrdd" do
+      host_info = WebFinger.host_meta()
+
+      assert String.contains?(host_info, MobilizonWeb.Endpoint.url())
+    end
+  end
+
+  describe "incoming webfinger request" do
+    test "works for fqns" do
+      actor = insert(:actor)
+
+      {:ok, result} =
+        WebFinger.webfinger("#{actor.preferred_username}@#{MobilizonWeb.Endpoint.host()}", "JSON")
+
+      assert is_map(result)
+    end
+
+    test "works for urls" do
+      actor = insert(:actor)
+
+      {:ok, result} = WebFinger.webfinger(actor.url, "JSON")
+      assert is_map(result)
+    end
+  end
+
+  describe "fingering" do
+    test "a mastodon actor" do
+      actor = "tcit@social.tcit.fr"
+
+      assert {:ok, %{"subject" => "acct:" <> actor, "url" => "https://social.tcit.fr/users/tcit"}} =
+               WebFinger.finger(actor)
+    end
+
+    test "a pleroma actor" do
+      actor = "@lain@pleroma.soykaf.com"
+
+      assert {:ok,
+              %{"subject" => "acct:" <> actor, "url" => "https://pleroma.soykaf.com/users/lain"}} =
+               WebFinger.finger(actor)
+    end
+
+    test "a peertube actor" do
+      actor = "framasoft@framatube.org"
+
+      assert {:ok,
+              %{
+                "subject" => "acct:" <> actor,
+                "url" => "https://framatube.org/accounts/framasoft"
+              }} = WebFinger.finger(actor)
+    end
+
+    test "a friendica actor" do
+      # Now with ActivityPub !
+      actor = "lain@squeet.me"
+
+      assert {:ok,
+              %{
+                "subject" => "acct:" <> actor,
+                "url" => "https://squeet.me/profile/lain"
+              }} = WebFinger.finger(actor)
+    end
+  end
+end