git.squeep.com Git - akkoma/blob - test/support/factory.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Factory do
   6   use ExMachina.Ecto, repo: Pleroma.Repo
   7
   8   def conversation_factory do
   9     %Pleroma.Conversation{
  10       ap_id: sequence(:ap_id, &"https://some_conversation/#{&1}")
  11     }
  12   end
  13
  14   def user_factory do
  15     user = %Pleroma.User{
  16       name: sequence(:name, &"Test テスト User #{&1}"),
  17       email: sequence(:email, &"user#{&1}@example.com"),
  18       nickname: sequence(:nickname, &"nick#{&1}"),
  19       password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
  20       bio: sequence(:bio, &"Tester Number #{&1}"),
  21       info: %{}
  22     }
  23
  24     %{
  25       user
  26       | ap_id: Pleroma.User.ap_id(user),
  27         follower_address: Pleroma.User.ap_followers(user),
  28         following: [Pleroma.User.ap_id(user)]
  29     }
  30   end
  31
  32   def note_factory(attrs \\ %{}) do
  33     text = sequence(:text, &"This is :moominmamma: note #{&1}")
  34
  35     user = insert(:user)
  36
  37     data = %{
  38       "type" => "Note",
  39       "content" => text,
  40       "id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
  41       "actor" => user.ap_id,
  42       "to" => ["https://www.w3.org/ns/activitystreams#Public"],
  43       "published" => DateTime.utc_now() |> DateTime.to_iso8601(),
  44       "likes" => [],
  45       "like_count" => 0,
  46       "context" => "2hu",
  47       "summary" => "2hu",
  48       "tag" => ["2hu"],
  49       "emoji" => %{
  50         "2hu" => "corndog.png"
  51       }
  52     }
  53
  54     %Pleroma.Object{
  55       data: merge_attributes(data, Map.get(attrs, :data, %{}))
  56     }
  57   end
  58
  59   def direct_note_factory do
  60     user2 = insert(:user)
  61
  62     %Pleroma.Object{data: data} = note_factory()
  63     %Pleroma.Object{data: Map.merge(data, %{"to" => [user2.ap_id]})}
  64   end
  65
  66   def article_factory do
  67     note_factory()
  68     |> Map.put("type", "Article")
  69   end
  70
  71   def tombstone_factory do
  72     data = %{
  73       "type" => "Tombstone",
  74       "id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
  75       "formerType" => "Note",
  76       "deleted" => DateTime.utc_now() |> DateTime.to_iso8601()
  77     }
  78
  79     %Pleroma.Object{
  80       data: data
  81     }
  82   end
  83
  84   def direct_note_activity_factory do
  85     dm = insert(:direct_note)
  86
  87     data = %{
  88       "id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
  89       "type" => "Create",
  90       "actor" => dm.data["actor"],
  91       "to" => dm.data["to"],
  92       "object" => dm.data,
  93       "published" => DateTime.utc_now() |> DateTime.to_iso8601(),
  94       "context" => dm.data["context"]
  95     }
  96
  97     %Pleroma.Activity{
  98       data: data,
  99       actor: data["actor"],
 100       recipients: data["to"]
 101     }
 102   end
 103
 104   def note_activity_factory(attrs \\ %{}) do
 105     note = attrs[:note] || insert(:note)
 106
 107     data = %{
 108       "id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
 109       "type" => "Create",
 110       "actor" => note.data["actor"],
 111       "to" => note.data["to"],
 112       "object" => note.data,
 113       "published" => DateTime.utc_now() |> DateTime.to_iso8601(),
 114       "context" => note.data["context"]
 115     }
 116
 117     %Pleroma.Activity{
 118       data: data,
 119       actor: data["actor"],
 120       recipients: data["to"]
 121     }
 122   end
 123
 124   def article_activity_factory do
 125     article = insert(:article)
 126
 127     data = %{
 128       "id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
 129       "type" => "Create",
 130       "actor" => article.data["actor"],
 131       "to" => article.data["to"],
 132       "object" => article.data,
 133       "published" => DateTime.utc_now() |> DateTime.to_iso8601(),
 134       "context" => article.data["context"]
 135     }
 136
 137     %Pleroma.Activity{
 138       data: data,
 139       actor: data["actor"],
 140       recipients: data["to"]
 141     }
 142   end
 143
 144   def announce_activity_factory(attrs \\ %{}) do
 145     note_activity = attrs[:note_activity] || insert(:note_activity)
 146     user = attrs[:user] || insert(:user)
 147
 148     data = %{
 149       "type" => "Announce",
 150       "actor" => note_activity.actor,
 151       "object" => note_activity.data["id"],
 152       "to" => [user.follower_address, note_activity.data["actor"]],
 153       "cc" => ["https://www.w3.org/ns/activitystreams#Public"],
 154       "context" => note_activity.data["context"]
 155     }
 156
 157     %Pleroma.Activity{
 158       data: data,
 159       actor: user.ap_id,
 160       recipients: data["to"]
 161     }
 162   end
 163
 164   def like_activity_factory do
 165     note_activity = insert(:note_activity)
 166     user = insert(:user)
 167
 168     data = %{
 169       "id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
 170       "actor" => user.ap_id,
 171       "type" => "Like",
 172       "object" => note_activity.data["object"]["id"],
 173       "published_at" => DateTime.utc_now() |> DateTime.to_iso8601()
 174     }
 175
 176     %Pleroma.Activity{
 177       data: data
 178     }
 179   end
 180
 181   def follow_activity_factory do
 182     follower = insert(:user)
 183     followed = insert(:user)
 184
 185     data = %{
 186       "id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
 187       "actor" => follower.ap_id,
 188       "type" => "Follow",
 189       "object" => followed.ap_id,
 190       "published_at" => DateTime.utc_now() |> DateTime.to_iso8601()
 191     }
 192
 193     %Pleroma.Activity{
 194       data: data,
 195       actor: follower.ap_id
 196     }
 197   end
 198
 199   def websub_subscription_factory do
 200     %Pleroma.Web.Websub.WebsubServerSubscription{
 201       topic: "http://example.org",
 202       callback: "http://example.org/callback",
 203       secret: "here's a secret",
 204       valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 100),
 205       state: "requested"
 206     }
 207   end
 208
 209   def websub_client_subscription_factory do
 210     %Pleroma.Web.Websub.WebsubClientSubscription{
 211       topic: "http://example.org",
 212       secret: "here's a secret",
 213       valid_until: nil,
 214       state: "requested",
 215       subscribers: []
 216     }
 217   end
 218
 219   def oauth_app_factory do
 220     %Pleroma.Web.OAuth.App{
 221       client_name: "Some client",
 222       redirect_uris: "https://example.com/callback",
 223       scopes: ["read", "write", "follow", "push"],
 224       website: "https://example.com",
 225       client_id: Ecto.UUID.generate(),
 226       client_secret: "aaa;/&bbb"
 227     }
 228   end
 229
 230   def instance_factory do
 231     %Pleroma.Instances.Instance{
 232       host: "domain.com",
 233       unreachable_since: nil
 234     }
 235   end
 236
 237   def oauth_token_factory do
 238     oauth_app = insert(:oauth_app)
 239
 240     %Pleroma.Web.OAuth.Token{
 241       token: :crypto.strong_rand_bytes(32) |> Base.url_encode64(),
 242       refresh_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64(),
 243       user: build(:user),
 244       app_id: oauth_app.id,
 245       valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10)
 246     }
 247   end
 248
 249   def oauth_authorization_factory do
 250     %Pleroma.Web.OAuth.Authorization{
 251       token: :crypto.strong_rand_bytes(32) |> Base.url_encode64(padding: false),
 252       scopes: ["read", "write", "follow", "push"],
 253       valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
 254       user: build(:user),
 255       app: build(:oauth_app)
 256     }
 257   end
 258
 259   def push_subscription_factory do
 260     %Pleroma.Web.Push.Subscription{
 261       user: build(:user),
 262       token: build(:oauth_token),
 263       endpoint: "https://example.com/example/1234",
 264       key_auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
 265       key_p256dh:
 266         "BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA=",
 267       data: %{}
 268     }
 269   end
 270
 271   def notification_factory do
 272     %Pleroma.Notification{
 273       user: build(:user)
 274     }
 275   end
 276
 277   def scheduled_activity_factory do
 278     %Pleroma.ScheduledActivity{
 279       user: build(:user),
 280       scheduled_at: NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(60), :millisecond),
 281       params: build(:note) |> Map.from_struct() |> Map.get(:data)
 282     }
 283   end
 284
 285   def registration_factory do
 286     user = insert(:user)
 287
 288     %Pleroma.Registration{
 289       user: user,
 290       provider: "twitter",
 291       uid: "171799000",
 292       info: %{
 293         "name" => "John Doe",
 294         "email" => "john@doe.com",
 295         "nickname" => "johndoe",
 296         "description" => "My bio"
 297       }
 298     }
 299   end
 300 end