mobilizon/test/web/controllers/feed_controller_test.exs

362 lines
12 KiB
Elixir
Raw Normal View History

2020-01-26 21:36:50 +01:00
defmodule Mobilizon.Web.FeedControllerTest do
use Mobilizon.Web.ConnCase
2019-09-22 16:26:23 +02:00
import Mobilizon.Factory
2019-09-22 16:26:23 +02:00
alias Mobilizon.Config
2020-01-26 21:36:50 +01:00
alias Mobilizon.Web.Endpoint
alias Mobilizon.Web.Router.Helpers, as: Routes
describe "/@:preferred_username/feed/atom" do
test "it returns an RSS representation of the actor's public events if the actor is publicly visible",
%{conn: conn} do
actor = insert(:actor, visibility: :public)
tag1 = insert(:tag, title: "RSS", slug: "rss")
tag2 = insert(:tag, title: "ATOM", slug: "atom")
event1 = insert(:event, organizer_actor: actor, tags: [tag1])
event2 = insert(:event, organizer_actor: actor, tags: [tag1, tag2])
event3 =
insert(:event,
organizer_actor: actor,
begins_on: DateTime.add(DateTime.utc_now(), -2, :day)
)
conn =
conn
|> get(
2019-09-22 13:41:24 +02:00
Endpoint
|> ~p"/@#{actor.preferred_username}/feed/atom"
|> URI.decode()
)
assert response(conn, 200) =~ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
assert response_content_type(conn, :xml) =~ "charset=utf-8"
{:ok, feed} = ElixirFeedParser.parse(conn.resp_body)
assert feed.title ==
actor.name <> "'s public events feed on #{Config.instance_name()}"
[entry1, entry2] = entries = feed.entries
Enum.each(entries, fn entry ->
assert entry.title in [event1.title, event2.title]
refute entry.title == event3.title
end)
# It seems categories takes term instead of Label
# <category label=\"RSS\" term=\"rss\"/>
assert entry1.categories == [tag2.title, tag1.title] |> Enum.map(&String.downcase/1)
assert entry2.categories == [tag1.title] |> Enum.map(&String.downcase/1)
end
test "it returns a 404 for the actor's public events Atom feed if the actor is not publicly visible",
%{conn: conn} do
actor = insert(:actor, visibility: :private)
tag1 = insert(:tag, title: "RSS", slug: "rss")
tag2 = insert(:tag, title: "ATOM", slug: "atom")
insert(:event, organizer_actor: actor, tags: [tag1])
insert(:event, organizer_actor: actor, tags: [tag1, tag2])
conn =
conn
|> get(
2019-09-22 13:41:24 +02:00
Endpoint
|> ~p"/@#{actor.preferred_username}/feed/atom"
|> URI.decode()
)
assert response(conn, 404)
end
test "it returns an RSS representation of the actor's public events with the proper accept header",
%{conn: conn} do
actor = insert(:actor, visibility: :unlisted)
conn =
conn
|> put_req_header("accept", "application/atom+xml")
|> get(
2019-09-22 13:41:24 +02:00
Endpoint
|> ~p"/@#{actor.preferred_username}/feed/atom"
|> URI.decode()
)
assert response(conn, 200) =~ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
assert response_content_type(conn, :xml) =~ "charset=utf-8"
end
test "it doesn't return anything for an not existing actor", %{conn: conn} do
conn =
conn
|> put_req_header("accept", "application/atom+xml")
|> get("/@notexistent/feed/atom")
assert response(conn, 404)
end
end
describe "/@:preferred_username/feed/ics" do
test "it returns an iCalendar representation of the actor's public events with an actor publicly visible",
%{conn: conn} do
actor = insert(:actor)
group = insert(:group, visibility: :public)
tag1 = insert(:tag, title: "iCalendar", slug: "icalendar")
tag2 = insert(:tag, title: "Apple", slug: "apple")
event1 =
insert(:event,
organizer_actor: actor,
attributed_to: group,
tags: [tag1],
title: "Event One"
)
event2 =
insert(:event,
organizer_actor: actor,
attributed_to: group,
tags: [tag1, tag2],
title: "Event Two",
begins_on: DateTime.add(DateTime.utc_now(), 4, :day)
)
event3 =
insert(:event,
organizer_actor: actor,
attributed_to: group,
title: "Event Three",
begins_on: DateTime.add(DateTime.utc_now(), -2, :day)
)
conn =
conn
|> get(URI.decode(~p"/@#{group.preferred_username}/feed/ics"))
assert res = response(conn, 200)
assert res =~ "BEGIN:VCALENDAR"
assert response_content_type(conn, :calendar) =~ "charset=utf-8"
[entry2, entry1] = entries = ExIcal.parse(res)
Enum.each(entries, fn entry ->
assert entry.summary in [event1.title, event2.title]
refute entry.summary == event3.title
end)
assert entry1.categories == [tag1.title]
assert entry2.categories == [tag1.title, tag2.title]
end
test "it returns a 404 page for the actor's public events iCal feed with an actor not publicly visible",
%{conn: conn} do
actor = insert(:group, visibility: :private)
tag1 = insert(:tag, title: "iCalendar", slug: "icalendar")
tag2 = insert(:tag, title: "Apple", slug: "apple")
insert(:event, organizer_actor: actor, tags: [tag1])
insert(:event, organizer_actor: actor, tags: [tag1, tag2])
conn =
conn
|> get(URI.decode(~p"/@#{actor.preferred_username}/feed/ics"))
assert response(conn, 404)
end
test "it returns an iCalendar representation of the actor's public events with the proper accept header",
%{conn: conn} do
actor = insert(:actor, visibility: :unlisted)
conn =
conn
|> put_req_header("accept", "text/calendar")
|> get(URI.decode(~p"/@#{actor.preferred_username}/feed/ics"))
assert response(conn, 200) =~ "BEGIN:VCALENDAR"
assert response_content_type(conn, :calendar) =~ "charset=utf-8"
end
test "it doesn't return anything for an not existing actor", %{conn: conn} do
conn =
conn
|> put_req_header("accept", "text/calendar")
|> get("/@notexistent/feed/ics")
assert response(conn, 404)
end
end
describe "/events/:uuid/export/ics" do
test "it returns an iCalendar representation of the event", %{conn: conn} do
tag1 = insert(:tag, title: "iCalendar", slug: "icalendar")
tag2 = insert(:tag, title: "Apple", slug: "apple")
event1 = insert(:event, tags: [tag1, tag2])
conn =
conn
|> get(
2019-09-22 13:41:24 +02:00
Endpoint
|> ~p"/events/#{event1.uuid}/export/ics"
|> URI.decode()
)
assert response(conn, 200) =~ "BEGIN:VCALENDAR"
assert response_content_type(conn, :calendar) =~ "charset=utf-8"
[entry1] = ExIcal.parse(conn.resp_body)
assert entry1.summary == event1.title
assert entry1.categories == [tag1.title, tag2.title]
end
end
describe "/events/going/:token/atom" do
test "it returns an atom feed of all events for all identities for an user token", %{
conn: conn
} do
user = insert(:user)
actor1 = insert(:actor, user: user)
actor2 = insert(:actor, user: user)
event1 = insert(:event)
event2 = insert(:event)
event3 = insert(:event, begins_on: DateTime.add(DateTime.utc_now(), -5, :day))
insert(:participant, event: event1, actor: actor1)
insert(:participant, event: event2, actor: actor2)
insert(:participant, event: event3, actor: actor2)
feed_token = insert(:feed_token, user: user, actor: nil)
conn =
conn
|> get(URI.decode(~p"/events/going/#{ShortUUID.encode!(feed_token.token)}", "atom"))
assert response(conn, 200) =~ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
assert response_content_type(conn, :xml) =~ "charset=utf-8"
{:ok, feed} = ElixirFeedParser.parse(conn.resp_body)
assert feed.title == "Feed for #{user.email} on #{Config.instance_name()}"
entries = feed.entries
Enum.each(entries, fn entry ->
assert entry.title in [event1.title, event2.title]
refute entry.title == event3.title
end)
end
test "it returns an atom feed of all events a single identity for an actor token", %{
conn: conn
} do
user = insert(:user)
actor1 = insert(:actor, user: user)
actor2 = insert(:actor, user: user)
event1 = insert(:event)
event2 = insert(:event)
event3 = insert(:event, begins_on: DateTime.add(DateTime.utc_now(), -5, :day))
insert(:participant, event: event1, actor: actor1)
insert(:participant, event: event2, actor: actor2)
insert(:participant, event: event3, actor: actor1)
feed_token = insert(:feed_token, user: user, actor: actor1)
conn =
conn
|> put_req_header("accept", "application/atom+xml")
|> get(URI.decode(~p"/events/going/#{ShortUUID.encode!(feed_token.token)}", "atom"))
assert response(conn, 200) =~ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
assert response_content_type(conn, :xml) =~ "charset=utf-8"
{:ok, feed} = ElixirFeedParser.parse(conn.resp_body)
assert feed.title ==
"#{actor1.name}'s private events feed on #{Config.instance_name()}"
[entry] = feed.entries
assert entry.title == event1.title
refute entry.title == event3.title
end
test "it returns 404 for an not existing feed", %{conn: conn} do
conn =
conn
|> get(URI.decode(~p"/events/going/not_existing/atom"))
assert response(conn, 404)
end
end
describe "/events/going/:token/ics" do
test "it returns an ical feed of all events for all identities for an user token", %{
conn: conn
} do
user = insert(:user)
actor1 = insert(:actor, user: user)
actor2 = insert(:actor, user: user)
event1 = insert(:event)
event2 = insert(:event)
event3 = insert(:event, begins_on: DateTime.add(DateTime.utc_now(), -5, :day))
insert(:participant, event: event1, actor: actor1)
insert(:participant, event: event2, actor: actor2)
insert(:participant, event: event3, actor: actor1)
feed_token = insert(:feed_token, user: user, actor: nil)
conn =
conn
|> put_req_header("accept", "text/calendar")
|> get(URI.decode(~p"/events/going/#{ShortUUID.encode!(feed_token.token)}", "ics"))
assert response(conn, 200) =~ "BEGIN:VCALENDAR"
assert response_content_type(conn, :calendar) =~ "charset=utf-8"
entries = ExIcal.parse(conn.resp_body)
Enum.each(entries, fn entry ->
assert entry.summary in [event1.title, event2.title]
refute entry.summary == event3.title
end)
end
test "it returns an ical feed of all events a single identity for an actor token", %{
conn: conn
} do
user = insert(:user)
actor1 = insert(:actor, user: user)
actor2 = insert(:actor, user: user)
event1 = insert(:event)
event2 = insert(:event)
event3 = insert(:event, begins_on: DateTime.add(DateTime.utc_now(), -5, :day))
insert(:participant, event: event1, actor: actor1)
insert(:participant, event: event2, actor: actor2)
insert(:participant, event: event3, actor: actor1)
feed_token = insert(:feed_token, user: user, actor: actor1)
conn =
conn
|> put_req_header("accept", "text/calendar")
|> get(URI.decode(~p"/events/going/#{ShortUUID.encode!(feed_token.token)}", "ics"))
assert response(conn, 200) =~ "BEGIN:VCALENDAR"
assert response_content_type(conn, :calendar) =~ "charset=utf-8"
[entry1] = ExIcal.parse(conn.resp_body)
assert entry1.summary == event1.title
assert entry1.categories == event1.tags |> Enum.map(& &1.title)
refute entry1.summary == event3.title
end
test "it returns 404 for an not existing feed", %{conn: conn} do
conn =
conn
|> get(
2019-09-22 13:41:24 +02:00
Endpoint
|> ~p"/events/going/not_existing/ics"
|> URI.decode()
)
assert response(conn, 404)
end
end
end