hamlab/mobilizon-frontend
2
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Move to GraphQL

Browse Source 
Signed-off-by: Thomas Citharel <tcit@tcit.fr>
This commit is contained in:
Thomas Citharel
2018-11-06 10:30:27 +01:00
parent 7e137d1a1c
commit b54dae7e15
149 changed files with 5605 additions and 4665 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
test/mobilizon_web/resolvers/actor_resolver_test.exs Normal file
View File

@@ -0,0 +1,78 @@
defmodule MobilizonWeb.Resolvers.ActorResolverTest do
use MobilizonWeb.ConnCase
alias Mobilizon.{Events, Actors}
alias Mobilizon.Actors.Actor
alias MobilizonWeb.AbsintheHelpers
import Mobilizon.Factory
@valid_actor_params %{email: "test@test.tld", password: "testest", username: "test"}
@non_existent_username "nonexistent"
describe "Actor Resolver" do
test "find_actor/3 returns an actor by it's username", context do
{:ok, actor} = Actors.register(@valid_actor_params)
query = """
{
actor(preferredUsername: "#{actor.preferred_username}") {
preferredUsername,
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "actor"))
assert json_response(res, 200)["data"]["actor"]["preferredUsername"] ==
actor.preferred_username
query = """
{
actor(preferredUsername: "#{@non_existent_username}") {
preferredUsername,
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "actor"))
assert json_response(res, 200)["data"]["actor"] == nil
assert hd(json_response(res, 200)["errors"])["message"] ==
"Actor with name #{@non_existent_username} not found"
end
test "get_current_actor/3 returns the current logged-in actor", context do
{:ok, actor} = Actors.register(@valid_actor_params)
query = """
{
loggedActor {
avatarUrl,
preferredUsername,
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "logged_actor"))
assert json_response(res, 200)["data"]["loggedActor"] == nil
assert hd(json_response(res, 200)["errors"])["message"] ==
"You need to be logged-in to view current actor"
res =
context.conn
|> auth_conn(actor.user)
|> get("/api", AbsintheHelpers.query_skeleton(query, "logged_actor"))
assert json_response(res, 200)["data"]["loggedActor"]["preferredUsername"] ==
actor.preferred_username
end
end
end

60
test/mobilizon_web/resolvers/category_resolver_test.exs Normal file
View File

@@ -0,0 +1,60 @@
defmodule MobilizonWeb.Resolvers.CategoryResolverTest do
use MobilizonWeb.ConnCase
alias Mobilizon.Actors
alias Mobilizon.Actors.Actor
alias MobilizonWeb.AbsintheHelpers
import Mobilizon.Factory
setup %{conn: conn} do
{:ok, %Actor{} = actor} =
Actors.register(%{email: "test@test.tld", password: "testest", username: "test"})
{:ok, conn: conn, actor: actor}
end
describe "Category Resolver" do
test "list_categories/3 returns the list of categories", context do
insert(:category)
insert(:category)
query = """
{
categories {
id,
title,
description,
picture {
url,
},
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "categories"))
assert json_response(res, 200)["data"]["categories"] |> length == 2
end
# We can't test an upload…yet?
# test "create_category/3 creates a category", %{conn: conn, actor: actor} do
# mutation = """
# mutation {
# createCategory(title: "my category", description: "my desc") {
# id,
# title,
# description,
# },
# }
# """
# res =
# conn
# |> auth_conn(actor.user)
# |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
# assert json_response(res, 200)["data"]["createCategory"]["title"] == "my category"
# end
end
end

167
test/mobilizon_web/resolvers/event_resolver_test.exs Normal file
View File

@@ -0,0 +1,167 @@
defmodule MobilizonWeb.Resolvers.EventResolverTest do
use MobilizonWeb.ConnCase
alias Mobilizon.{Events, Actors}
alias Mobilizon.Actors.Actor
alias MobilizonWeb.AbsintheHelpers
import Mobilizon.Factory
@event %{description: "some body", title: "some title", begins_on: Ecto.DateTime.utc()}
setup %{conn: conn} do
{:ok, %Actor{} = actor} =
Actors.register(%{email: "test@test.tld", password: "testest", username: "test"})
{:ok, conn: conn, actor: actor}
end
describe "Event Resolver" do
test "find_event/3 returns an event", context do
category = insert(:category)
event =
@event
|> Map.put(:organizer_actor_id, context.actor.id)
|> Map.put(:category_id, category.id)
{:ok, event} = Events.create_event(event)
query = """
{
event(uuid: "#{event.uuid}") {
uuid,
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "event"))
assert json_response(res, 200)["data"]["event"]["uuid"] == to_string(event.uuid)
query = """
{
event(uuid: "bad uuid") {
uuid,
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "event"))
assert [%{"message" => "Argument \"uuid\" has invalid value \"bad uuid\"."}] =
json_response(res, 400)["errors"]
end
test "list_participants_for_event/3 returns participants for an event", context do
# Plain event
category = insert(:category)
event =
@event
|> Map.put(:organizer_actor_id, context.actor.id)
|> Map.put(:category_id, category.id)
{:ok, event} = Events.create_event(event)
query = """
{
participants(uuid: "#{event.uuid}") {
role,
actor {
preferredUsername
}
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "participants"))
assert json_response(res, 200)["data"]["participants"] == [
%{
"actor" => %{"preferredUsername" => context.actor.preferred_username},
"role" => 4
}
]
# Adding a participant
actor2 = insert(:actor)
participant = insert(:participant, event: event, actor: actor2)
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "participants"))
assert json_response(res, 200)["data"]["participants"] == [
%{
"actor" => %{"preferredUsername" => context.actor.preferred_username},
"role" => 4
},
%{
"actor" => %{"preferredUsername" => participant.actor.preferred_username},
"role" => 0
}
]
end
test "create_event/3 creates an event", %{conn: conn, actor: actor} do
category = insert(:category)
mutation = """
mutation {
createEvent(
title: "come to my event",
description: "it will be fine",
beginsOn: "#{DateTime.utc_now() |> DateTime.to_iso8601()}",
organizer_actor_id: #{actor.id},
category_id: #{category.id},
addressType: #{"OTHER"}
) {
title,
uuid
}
}
"""
res =
conn
|> auth_conn(actor.user)
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert json_response(res, 200)["data"]["createEvent"]["title"] == "come to my event"
end
test "search_events_and_actors/3 finds events and actors", %{conn: conn, actor: actor} do
event = insert(:event, title: "test")
query = """
{
search(search: "test") {
...on Event {
title,
uuid,
__typename
},
...on Actor {
preferredUsername,
__typename
}
}
}
"""
res =
conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "search"))
assert hd(json_response(res, 200)["data"]["search"])["uuid"] == to_string(event.uuid)
assert hd(tl(json_response(res, 200)["data"]["search"]))["preferredUsername"] ==
actor.preferred_username
end
end
end

239
test/mobilizon_web/resolvers/user_resolver_test.exs Normal file
View File

@@ -0,0 +1,239 @@
defmodule MobilizonWeb.Resolvers.UserResolverTest do
use MobilizonWeb.ConnCase
alias Mobilizon.{Events, Actors}
alias Mobilizon.Actors.{Actor, User}
alias MobilizonWeb.AbsintheHelpers
import Mobilizon.Factory
use Bamboo.Test
@valid_actor_params %{email: "test@test.tld", password: "testest", username: "test"}
@non_existent_username "nonexistent"
describe "User Resolver" do
test "find_user/3 returns an user by it's id", context do
user = insert(:user)
query = """
{
user(id: "#{user.id}") {
email,
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "user"))
assert json_response(res, 200)["data"]["user"]["email"] == user.email
query = """
{
user(id: "#{0}") {
email,
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "user"))
assert json_response(res, 200)["data"]["user"] == nil
assert hd(json_response(res, 200)["errors"])["message"] == "User with ID #{0} not found"
end
test "get_current_user/3 returns the current logged-in user", context do
user = insert(:user)
query = """
{
loggedUser {
id
}
}
"""
res =
context.conn
|> get("/api", AbsintheHelpers.query_skeleton(query, "logged_user"))
assert json_response(res, 200)["data"]["loggedUser"] == nil
assert hd(json_response(res, 200)["errors"])["message"] ==
"You need to be logged-in to view current user"
res =
context.conn
|> auth_conn(user)
|> get("/api", AbsintheHelpers.query_skeleton(query, "logged_user"))
assert json_response(res, 200)["data"]["loggedUser"]["id"] == to_string(user.id)
end
end
@account_creation %{email: "test@demo.tld", password: "long password", username: "test_account"}
@account_creation_bad_email %{
email: "y@l@",
password: "long password",
username: "test_account"
}
test "test create_user_actor/3 creates an user", context do
mutation = """
mutation {
createUser(
email: "#{@account_creation.email}",
password: "#{@account_creation.password}",
username: "#{@account_creation.username}"
) {
preferred_username,
user {
email
}
}
}
"""
res =
context.conn
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert json_response(res, 200)["data"]["createUser"]["preferred_username"] ==
@account_creation.username
assert json_response(res, 200)["data"]["createUser"]["user"]["email"] ==
@account_creation.email
end
test "test create_user_actor/3 doesn't create an user with bad email", context do
mutation = """
mutation {
createUser(
email: "#{@account_creation_bad_email.email}",
password: "#{@account_creation.password}",
username: "#{@account_creation.username}"
) {
preferred_username,
user {
email
}
}
}
"""
res =
context.conn
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] == "Email doesn't fit required format"
end
@valid_actor_params %{email: "test@test.tld", password: "testest", username: "test"}
test "test validate_user/3 validates an user", context do
{:ok, actor} = Actors.register(@valid_actor_params)
mutation = """
mutation {
validateUser(
token: "#{actor.user.confirmation_token}"
) {
token,
user {
id
},
actor {
preferredUsername
}
}
}
"""
res =
context.conn
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert json_response(res, 200)["data"]["validateUser"]["actor"]["preferredUsername"] == @valid_actor_params.username
assert json_response(res, 200)["data"]["validateUser"]["user"]["id"] ==
to_string(actor.user.id)
end
test "test validate_user/3 with invalid token doesn't validate an user", context do
{:ok, actor} = Actors.register(@valid_actor_params)
mutation = """
mutation {
validateUser(
token: "no pass"
) {
token,
user {
id
},
actor {
preferredUsername
}
}
}
"""
res =
context.conn
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] == "Invalid token"
end
test "test resend_confirmation_email/3 with valid email resends an validation email", context do
{:ok, actor} = Actors.register(@valid_actor_params)
mutation = """
mutation {
resendConfirmationEmail(
email: "#{actor.user.email}"
)
}
"""
res =
context.conn
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] == "You requested again a confirmation email too soon"
# Hammer time !
Mobilizon.Actors.update_user(actor.user, %{
confirmation_sent_at: Timex.shift(actor.user.confirmation_sent_at, hours: -3)
})
res =
context.conn
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert json_response(res, 200)["data"]["resendConfirmationEmail"] == actor.user.email
assert_delivered_email Mobilizon.Email.User.confirmation_email(actor.user)
end
test "test resend_confirmation_email/3 with invalid email resends an validation email", context do
{:ok, actor} = Actors.register(@valid_actor_params)
mutation = """
mutation {
resendConfirmationEmail(
email: "oh no"
)
}
"""
res =
context.conn
|> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
assert hd(json_response(res, 200)["errors"])["message"] == "No user to validate with this email was found"
end
end