Add groups back

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

test/eventos/accounts/accounts_test.exs

@@ -1,153 +0,0 @@
-defmodule Eventos.AccountsTest do
-  use Eventos.DataCase
-
-  alias Eventos.Accounts
-
-  describe "accounts" do
-    alias Eventos.Accounts.Account
-
-    @valid_attrs %{description: "some description", display_name: "some display_name", domain: "some domain", private_key: "some private_key", public_key: "some public_key", suspended: true, uri: "some uri", url: "some url", username: "some username"}
-    @update_attrs %{description: "some updated description", display_name: "some updated display_name", domain: "some updated domain", private_key: "some updated private_key", public_key: "some updated public_key", suspended: false, uri: "some updated uri", url: "some updated url", username: "some updated username"}
-    @invalid_attrs %{description: nil, display_name: nil, domain: nil, private_key: nil, public_key: nil, suspended: nil, uri: nil, url: nil, username: nil}
-
-    def account_fixture(attrs \\ %{}) do
-      {:ok, account} =
-        attrs
-        |> Enum.into(@valid_attrs)
-        |> Accounts.create_account()
-
-      account
-    end
-
-    test "list_accounts/0 returns all accounts" do
-      account = account_fixture()
-      assert Accounts.list_accounts() == [account]
-    end
-
-    test "get_account!/1 returns the account with given id" do
-      account = account_fixture()
-      assert Accounts.get_account!(account.id) == account
-    end
-
-    test "create_account/1 with valid data creates a account" do
-      assert {:ok, %Account{} = account} = Accounts.create_account(@valid_attrs)
-      assert account.description == "some description"
-      assert account.display_name == "some display_name"
-      assert account.domain == "some domain"
-      assert account.private_key == "some private_key"
-      assert account.public_key == "some public_key"
-      assert account.suspended
-      assert account.uri == "some uri"
-      assert account.url == "some url"
-      assert account.username == "some username"
-    end
-
-    test "create_account/1 with invalid data returns error changeset" do
-      assert {:error, %Ecto.Changeset{}} = Accounts.create_account(@invalid_attrs)
-    end
-
-    test "update_account/2 with valid data updates the account" do
-      account = account_fixture()
-      assert {:ok, account} = Accounts.update_account(account, @update_attrs)
-      assert %Account{} = account
-      assert account.description == "some updated description"
-      assert account.display_name == "some updated display_name"
-      assert account.domain == "some updated domain"
-      assert account.private_key == "some updated private_key"
-      assert account.public_key == "some updated public_key"
-      refute account.suspended
-      assert account.uri == "some updated uri"
-      assert account.url == "some updated url"
-      assert account.username == "some updated username"
-    end
-
-    test "update_account/2 with invalid data returns error changeset" do
-      account = account_fixture()
-      assert {:error, %Ecto.Changeset{}} = Accounts.update_account(account, @invalid_attrs)
-      assert account == Accounts.get_account!(account.id)
-    end
-
-    test "delete_account/1 deletes the account" do
-      account = account_fixture()
-      assert {:ok, %Account{}} = Accounts.delete_account(account)
-      assert_raise Ecto.NoResultsError, fn -> Accounts.get_account!(account.id) end
-    end
-
-    test "change_account/1 returns a account changeset" do
-      account = account_fixture()
-      assert %Ecto.Changeset{} = Accounts.change_account(account)
-    end
-  end
-
-  describe "users" do
-    alias Eventos.Accounts.{User, Account}
-
-    @account_valid_attrs %{description: "some description", display_name: "some display_name", domain: "some domain", private_key: "some private_key", public_key: "some public_key", suspended: true, uri: "some uri", url: "some url", username: "some username"}
-    @valid_attrs %{email: "foo@bar.tld", password_hash: "some password_hash", role: 42}
-    @update_attrs %{email: "foo@fighters.tld", password_hash: "some updated password_hash", role: 43}
-    @invalid_attrs %{email: nil, password_hash: nil, role: nil}
-
-    def user_fixture(attrs \\ %{}) do
-      {:ok, account} =
-        attrs
-        |> Enum.into(@account_valid_attrs)
-        |> Accounts.create_account()
-      valid_attrs_with_account_id = Map.put(@valid_attrs, :account_id, account.id)
-      {:ok, user} =
-        attrs
-        |> Enum.into(valid_attrs_with_account_id)
-        |> Accounts.create_user()
-
-      user
-    end
-
-    test "list_users/0 returns all users" do
-      user = user_fixture()
-      assert Accounts.list_users() == [user]
-    end
-
-    test "get_user!/1 returns the user with given id" do
-      user = user_fixture()
-      assert Accounts.get_user!(user.id) == user
-    end
-
-    test "create_user/1 with valid data creates a user" do
-      {:ok, %Account{} = account} = Accounts.create_account(@account_valid_attrs)
-      attrs = Map.put(@valid_attrs, :account_id, account.id)
-      assert {:ok, %User{} = user} = Accounts.create_user(attrs)
-      assert user.email == "foo@bar.tld"
-      assert user.password_hash == "some password_hash"
-      assert user.role == 42
-    end
-
-    test "create_user/1 with invalid data returns error changeset" do
-      assert {:error, %Ecto.Changeset{}} = Accounts.create_user(@invalid_attrs)
-    end
-
-    test "update_user/2 with valid data updates the user" do
-      user = user_fixture()
-      assert {:ok, user} = Accounts.update_user(user, @update_attrs)
-      assert %User{} = user
-      assert user.email == "foo@fighters.tld"
-      assert user.password_hash == "some updated password_hash"
-      assert user.role == 43
-    end
-
-    test "update_user/2 with invalid data returns error changeset" do
-      user = user_fixture()
-      assert {:error, %Ecto.Changeset{}} = Accounts.update_user(user, @invalid_attrs)
-      assert user == Accounts.get_user!(user.id)
-    end
-
-    test "delete_user/1 deletes the user" do
-      user = user_fixture()
-      assert {:ok, %User{}} = Accounts.delete_user(user)
-      assert_raise Ecto.NoResultsError, fn -> Accounts.get_user!(user.id) end
-    end
-
-    test "change_user/1 returns a user changeset" do
-      user = user_fixture()
-      assert %Ecto.Changeset{} = Accounts.change_user(user)
-    end
-  end
-end

test/eventos/actors/actors_test.exs

@@ -3,6 +3,177 @@ defmodule Eventos.ActorsTest do
 
   alias Eventos.Actors
 
+  describe "actors" do
+    alias Eventos.Actors.Actor
+
+    @valid_attrs %{description: "some description", display_name: "some display_name", domain: "some domain", private_key: "some private_key", public_key: "some public_key", suspended: true, uri: "some uri", url: "some url", username: "some username"}
+    @update_attrs %{description: "some updated description", display_name: "some updated display_name", domain: "some updated domain", private_key: "some updated private_key", public_key: "some updated public_key", suspended: false, uri: "some updated uri", url: "some updated url", username: "some updated username"}
+    @invalid_attrs %{description: nil, display_name: nil, domain: nil, private_key: nil, public_key: nil, suspended: nil, uri: nil, url: nil, username: nil}
+
+    def actor_fixture(attrs \\ %{}) do
+      {:ok, actor} =
+        attrs
+        |> Enum.into(@valid_attrs)
+        |> Actors.create_actor()
+
+      actor
+    end
+
+    test "list_actors/0 returns all actors" do
+      actor = actor_fixture()
+      assert Actors.list_actors() == [actor]
+    end
+
+    test "get_actor!/1 returns the actor with given id" do
+      actor = actor_fixture()
+      assert Actors.get_actor!(actor.id) == actor
+    end
+
+    test "create_actor/1 with valid data creates a actor" do
+      assert {:ok, %Actor{} = actor} = Actors.create_actor(@valid_attrs)
+      assert actor.description == "some description"
+      assert actor.display_name == "some display_name"
+      assert actor.domain == "some domain"
+      assert actor.private_key == "some private_key"
+      assert actor.public_key == "some public_key"
+      assert actor.suspended
+      assert actor.uri == "some uri"
+      assert actor.url == "some url"
+      assert actor.username == "some username"
+    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" do
+      actor = actor_fixture()
+      assert {:ok, actor} = Actors.update_actor(actor, @update_attrs)
+      assert %Actor{} = actor
+      assert actor.description == "some updated description"
+      assert actor.display_name == "some updated display_name"
+      assert actor.domain == "some updated domain"
+      assert actor.private_key == "some updated private_key"
+      assert actor.public_key == "some updated public_key"
+      refute actor.suspended
+      assert actor.uri == "some updated uri"
+      assert actor.url == "some updated url"
+      assert actor.username == "some updated username"
+    end
+
+    test "update_actor/2 with invalid data returns error changeset" do
+      actor = actor_fixture()
+      assert {:error, %Ecto.Changeset{}} = Actors.update_actor(actor, @invalid_attrs)
+      assert actor == Actors.get_actor!(actor.id)
+    end
+
+    test "delete_actor/1 deletes the actor" do
+      actor = actor_fixture()
+      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()
+      assert %Ecto.Changeset{} = Actors.change_actor(actor)
+    end
+  end
+
+  describe "users" do
+    alias Eventos.Actors.{User, Actor}
+
+    @actor_valid_attrs %{description: "some description", display_name: "some display_name", domain: "some domain", private_key: "some private_key", public_key: "some public_key", suspended: true, uri: "some uri", url: "some url", username: "some username"}
+    @valid_attrs %{email: "foo@bar.tld", password_hash: "some password_hash", role: 42}
+    @update_attrs %{email: "foo@fighters.tld", password_hash: "some updated password_hash", role: 43}
+    @invalid_attrs %{email: nil, password_hash: nil, role: nil}
+
+    def user_fixture(attrs \\ %{}) do
+      {:ok, actor} =
+        attrs
+        |> Enum.into(@actor_valid_attrs)
+        |> Actors.create_actor()
+      valid_attrs_with_actor_id = Map.put(@valid_attrs, :actor_id, actor.id)
+      {:ok, user} =
+        attrs
+        |> Enum.into(valid_attrs_with_actor_id)
+        |> Actors.create_user()
+
+      user
+    end
+
+    test "list_users/0 returns all users" do
+      user = user_fixture()
+      assert Actors.list_users() == [user]
+    end
+
+    test "get_user!/1 returns the user with given id" do
+      user = user_fixture()
+      assert Actors.get_user!(user.id) == user
+    end
+
+    test "create_user/1 with valid data creates a user" do
+      {:ok, %Actor{} = actor} = Actors.create_actor(@actor_valid_attrs)
+      attrs = Map.put(@valid_attrs, :actor_id, actor.id)
+      assert {:ok, %User{} = user} = Actors.create_user(attrs)
+      assert user.email == "foo@bar.tld"
+      assert user.password_hash == "some password_hash"
+      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.password_hash == "some updated password_hash"
+      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
+  end
+
+  describe "groups" do
+
+    alias Eventos.Actors
+    alias Eventos.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 Eventos.Actors
+
   describe "bots" do
     alias Eventos.Actors.Bot
 

test/eventos/groups/groups_test.exs

@@ -1,193 +0,0 @@
-defmodule Eventos.GroupsTest do
-  use Eventos.DataCase
-
-  alias Eventos.Groups
-
-  describe "groups" do
-    alias Eventos.Groups.Group
-
-    @valid_attrs %{description: "some description", suspended: true, title: "some title", uri: "some uri", url: "some url"}
-    @update_attrs %{description: "some updated description", suspended: false, title: "some updated title", uri: "some updated uri", url: "some updated url"}
-    @invalid_attrs %{description: nil, suspended: nil, title: nil, uri: nil, url: nil}
-
-    def group_fixture(attrs \\ %{}) do
-      {:ok, group} =
-        attrs
-        |> Enum.into(@valid_attrs)
-        |> Groups.create_group()
-
-      group
-    end
-
-    test "list_groups/0 returns all groups" do
-      group = group_fixture()
-      assert Groups.list_groups() == [group]
-    end
-
-    test "get_group!/1 returns the group with given id" do
-      group = group_fixture()
-      assert Groups.get_group!(group.id) == group
-    end
-
-    test "create_group/1 with valid data creates a group" do
-      assert {:ok, %Group{} = group} = Groups.create_group(@valid_attrs)
-      assert group.description == "some description"
-      assert group.suspended
-      assert group.title == "some title"
-      assert group.uri == "some uri"
-      assert group.url == "some url"
-    end
-
-    test "create_group/1 with invalid data returns error changeset" do
-      assert {:error, %Ecto.Changeset{}} = Groups.create_group(@invalid_attrs)
-    end
-
-    test "update_group/2 with valid data updates the group" do
-      group = group_fixture()
-      assert {:ok, group} = Groups.update_group(group, @update_attrs)
-      assert %Group{} = group
-      assert group.description == "some updated description"
-      refute group.suspended
-      assert group.title == "some updated title"
-      assert group.uri == "some updated uri"
-      assert group.url == "some updated url"
-    end
-
-    test "update_group/2 with invalid data returns error changeset" do
-      group = group_fixture()
-      assert {:error, %Ecto.Changeset{}} = Groups.update_group(group, @invalid_attrs)
-      assert group == Groups.get_group!(group.id)
-    end
-
-    test "delete_group/1 deletes the group" do
-      group = group_fixture()
-      assert {:ok, %Group{}} = Groups.delete_group(group)
-      assert_raise Ecto.NoResultsError, fn -> Groups.get_group!(group.id) end
-    end
-
-    test "change_group/1 returns a group changeset" do
-      group = group_fixture()
-      assert %Ecto.Changeset{} = Groups.change_group(group)
-    end
-  end
-#
-#  describe "members" do
-#    alias Eventos.Groups.Member
-#
-#    @valid_attrs %{role: 42}
-#    @update_attrs %{role: 43}
-#    @invalid_attrs %{role: nil}
-#
-#    def member_fixture(attrs \\ %{}) do
-#      {:ok, member} =
-#        attrs
-#        |> Enum.into(@valid_attrs)
-#        |> Groups.create_member()
-#
-#      member
-#    end
-#
-#    test "list_members/0 returns all members" do
-#      member = member_fixture()
-#      assert Groups.list_members() == [member]
-#    end
-#
-#    test "get_member!/1 returns the member with given id" do
-#      member = member_fixture()
-#      assert Groups.get_member!(member.id) == member
-#    end
-#
-#    test "create_member/1 with valid data creates a member" do
-#      assert {:ok, %Member{} = member} = Groups.create_member(@valid_attrs)
-#      assert member.role == 42
-#    end
-#
-#    test "create_member/1 with invalid data returns error changeset" do
-#      assert {:error, %Ecto.Changeset{}} = Groups.create_member(@invalid_attrs)
-#    end
-#
-#    test "update_member/2 with valid data updates the member" do
-#      member = member_fixture()
-#      assert {:ok, member} = Groups.update_member(member, @update_attrs)
-#      assert %Member{} = member
-#      assert member.role == 43
-#    end
-#
-#    test "update_member/2 with invalid data returns error changeset" do
-#      member = member_fixture()
-#      assert {:error, %Ecto.Changeset{}} = Groups.update_member(member, @invalid_attrs)
-#      assert member == Groups.get_member!(member.id)
-#    end
-#
-#    test "delete_member/1 deletes the member" do
-#      member = member_fixture()
-#      assert {:ok, %Member{}} = Groups.delete_member(member)
-#      assert_raise Ecto.NoResultsError, fn -> Groups.get_member!(member.id) end
-#    end
-#
-#    test "change_member/1 returns a member changeset" do
-#      member = member_fixture()
-#      assert %Ecto.Changeset{} = Groups.change_member(member)
-#    end
-#  end
-#
-#  describe "requests" do
-#    alias Eventos.Groups.Request
-#
-#    @valid_attrs %{state: 42}
-#    @update_attrs %{state: 43}
-#    @invalid_attrs %{state: nil}
-#
-#    def request_fixture(attrs \\ %{}) do
-#      {:ok, request} =
-#        attrs
-#        |> Enum.into(@valid_attrs)
-#        |> Groups.create_request()
-#
-#      request
-#    end
-#
-#    test "list_requests/0 returns all requests" do
-#      request = request_fixture()
-#      assert Groups.list_requests() == [request]
-#    end
-#
-#    test "get_request!/1 returns the request with given id" do
-#      request = request_fixture()
-#      assert Groups.get_request!(request.id) == request
-#    end
-#
-#    test "create_request/1 with valid data creates a request" do
-#      assert {:ok, %Request{} = request} = Groups.create_request(@valid_attrs)
-#      assert request.state == 42
-#    end
-#
-#    test "create_request/1 with invalid data returns error changeset" do
-#      assert {:error, %Ecto.Changeset{}} = Groups.create_request(@invalid_attrs)
-#    end
-#
-#    test "update_request/2 with valid data updates the request" do
-#      request = request_fixture()
-#      assert {:ok, request} = Groups.update_request(request, @update_attrs)
-#      assert %Request{} = request
-#      assert request.state == 43
-#    end
-#
-#    test "update_request/2 with invalid data returns error changeset" do
-#      request = request_fixture()
-#      assert {:error, %Ecto.Changeset{}} = Groups.update_request(request, @invalid_attrs)
-#      assert request == Groups.get_request!(request.id)
-#    end
-#
-#    test "delete_request/1 deletes the request" do
-#      request = request_fixture()
-#      assert {:ok, %Request{}} = Groups.delete_request(request)
-#      assert_raise Ecto.NoResultsError, fn -> Groups.get_request!(request.id) end
-#    end
-#
-#    test "change_request/1 returns a request changeset" do
-#      request = request_fixture()
-#      assert %Ecto.Changeset{} = Groups.change_request(request)
-#    end
-#  end
-end

test/support/factory.ex

@@ -6,19 +6,19 @@ defmodule Eventos.Factory do
   use ExMachina.Ecto, repo: Eventos.Repo
 
   def user_factory do
-    %Eventos.Accounts.User{
+    %Eventos.Actors.User{
       password_hash: "Jane Smith",
       email: sequence(:email, &"email-#{&1}@example.com"),
       role: 0,
-      account: build(:account)
+      actor: build(:actor)
     }
   end
 
-  def account_factory do
+  def actor_factory do
     {:ok, {_, pubkey}} = RsaEx.generate_keypair("4096")
     username = sequence("thomas")
-    %Eventos.Accounts.Account{
-      username: username,
+    %Eventos.Actors.Actor{
+      preferred_username: username,
       domain: nil,
       public_key: pubkey,
       url: EventosWeb.Endpoint.url() <> "/@#{username}"
@@ -46,7 +46,7 @@ defmodule Eventos.Factory do
   end
 
   def event_factory do
-    account = build(:account)
+    actor = build(:actor)
     slug = sequence("my-event")
 
     %Eventos.Events.Event{
@@ -55,10 +55,10 @@ defmodule Eventos.Factory do
       description: "My desc",
       begins_on: nil,
       ends_on: nil,
-      organizer_account: account,
+      organizer_actor: actor,
       category: build(:category),
       address: build(:address),
-      url: EventosWeb.Endpoint.url() <> "/@" <> account.username <> "/" <> slug
+      url: EventosWeb.Endpoint.url() <> "/@" <> actor.username <> "/" <> slug
     }
   end
 
@@ -78,12 +78,13 @@ defmodule Eventos.Factory do
   end
 
   def group_factory do
-    %Eventos.Groups.Group{
-      title: sequence("My Group"),
-      description: "My group",
+    username = sequence("My Group")
+    %Eventos.Actors.Actor{
+      preferred_username: username,
+      summary: "My group",
       suspended: false,
-      url: "https://",
-      address: build(:address)
+      url: EventosWeb.Endpoint.url() <> "/@#{username}",
+      type: "Group",
     }
   end
 end