mirror of
https://github.com/philomena-dev/philomena.git
synced 2024-11-23 20:18:00 +01:00
we'll add these later
This commit is contained in:
byte[]
parent
51d5bede72
commit
1da0087896
56 changed files with 0 additions and 5155 deletions
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.AdvertsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Adverts
|
||||
|
||||
describe "adverts" do
|
||||
alias Philomena.Adverts.Advert
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def advert_fixture(attrs \\ %{}) do
|
||||
{:ok, advert} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Adverts.create_advert()
|
||||
|
||||
advert
|
||||
end
|
||||
|
||||
test "list_adverts/0 returns all adverts" do
|
||||
advert = advert_fixture()
|
||||
assert Adverts.list_adverts() == [advert]
|
||||
end
|
||||
|
||||
test "get_advert!/1 returns the advert with given id" do
|
||||
advert = advert_fixture()
|
||||
assert Adverts.get_advert!(advert.id) == advert
|
||||
end
|
||||
|
||||
test "create_advert/1 with valid data creates a advert" do
|
||||
assert {:ok, %Advert{} = advert} = Adverts.create_advert(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_advert/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Adverts.create_advert(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_advert/2 with valid data updates the advert" do
|
||||
advert = advert_fixture()
|
||||
assert {:ok, %Advert{} = advert} = Adverts.update_advert(advert, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_advert/2 with invalid data returns error changeset" do
|
||||
advert = advert_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Adverts.update_advert(advert, @invalid_attrs)
|
||||
assert advert == Adverts.get_advert!(advert.id)
|
||||
end
|
||||
|
||||
test "delete_advert/1 deletes the advert" do
|
||||
advert = advert_fixture()
|
||||
assert {:ok, %Advert{}} = Adverts.delete_advert(advert)
|
||||
assert_raise Ecto.NoResultsError, fn -> Adverts.get_advert!(advert.id) end
|
||||
end
|
||||
|
||||
test "change_advert/1 returns a advert changeset" do
|
||||
advert = advert_fixture()
|
||||
assert %Ecto.Changeset{} = Adverts.change_advert(advert)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,121 +0,0 @@
|
|||
defmodule Philomena.BadgesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Badges
|
||||
|
||||
describe "badges" do
|
||||
alias Philomena.Badges.Badge
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def badge_fixture(attrs \\ %{}) do
|
||||
{:ok, badge} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Badges.create_badge()
|
||||
|
||||
badge
|
||||
end
|
||||
|
||||
test "list_badges/0 returns all badges" do
|
||||
badge = badge_fixture()
|
||||
assert Badges.list_badges() == [badge]
|
||||
end
|
||||
|
||||
test "get_badge!/1 returns the badge with given id" do
|
||||
badge = badge_fixture()
|
||||
assert Badges.get_badge!(badge.id) == badge
|
||||
end
|
||||
|
||||
test "create_badge/1 with valid data creates a badge" do
|
||||
assert {:ok, %Badge{} = badge} = Badges.create_badge(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_badge/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Badges.create_badge(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_badge/2 with valid data updates the badge" do
|
||||
badge = badge_fixture()
|
||||
assert {:ok, %Badge{} = badge} = Badges.update_badge(badge, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_badge/2 with invalid data returns error changeset" do
|
||||
badge = badge_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Badges.update_badge(badge, @invalid_attrs)
|
||||
assert badge == Badges.get_badge!(badge.id)
|
||||
end
|
||||
|
||||
test "delete_badge/1 deletes the badge" do
|
||||
badge = badge_fixture()
|
||||
assert {:ok, %Badge{}} = Badges.delete_badge(badge)
|
||||
assert_raise Ecto.NoResultsError, fn -> Badges.get_badge!(badge.id) end
|
||||
end
|
||||
|
||||
test "change_badge/1 returns a badge changeset" do
|
||||
badge = badge_fixture()
|
||||
assert %Ecto.Changeset{} = Badges.change_badge(badge)
|
||||
end
|
||||
end
|
||||
|
||||
describe "badge_awards" do
|
||||
alias Philomena.Badges.BadgeAward
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def badge_award_fixture(attrs \\ %{}) do
|
||||
{:ok, badge_award} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Badges.create_badge_award()
|
||||
|
||||
badge_award
|
||||
end
|
||||
|
||||
test "list_badge_awards/0 returns all badge_awards" do
|
||||
badge_award = badge_award_fixture()
|
||||
assert Badges.list_badge_awards() == [badge_award]
|
||||
end
|
||||
|
||||
test "get_badge_award!/1 returns the badge_award with given id" do
|
||||
badge_award = badge_award_fixture()
|
||||
assert Badges.get_badge_award!(badge_award.id) == badge_award
|
||||
end
|
||||
|
||||
test "create_badge_award/1 with valid data creates a badge_award" do
|
||||
assert {:ok, %BadgeAward{} = badge_award} = Badges.create_badge_award(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_badge_award/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Badges.create_badge_award(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_badge_award/2 with valid data updates the badge_award" do
|
||||
badge_award = badge_award_fixture()
|
||||
|
||||
assert {:ok, %BadgeAward{} = badge_award} =
|
||||
Badges.update_badge_award(badge_award, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_badge_award/2 with invalid data returns error changeset" do
|
||||
badge_award = badge_award_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Badges.update_badge_award(badge_award, @invalid_attrs)
|
||||
assert badge_award == Badges.get_badge_award!(badge_award.id)
|
||||
end
|
||||
|
||||
test "delete_badge_award/1 deletes the badge_award" do
|
||||
badge_award = badge_award_fixture()
|
||||
assert {:ok, %BadgeAward{}} = Badges.delete_badge_award(badge_award)
|
||||
assert_raise Ecto.NoResultsError, fn -> Badges.get_badge_award!(badge_award.id) end
|
||||
end
|
||||
|
||||
test "change_badge_award/1 returns a badge_award changeset" do
|
||||
badge_award = badge_award_fixture()
|
||||
assert %Ecto.Changeset{} = Badges.change_badge_award(badge_award)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,178 +0,0 @@
|
|||
defmodule Philomena.BansTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Bans
|
||||
|
||||
describe "fingerprint_bans" do
|
||||
alias Philomena.Bans.Fingerprint
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fingerprint_fixture(attrs \\ %{}) do
|
||||
{:ok, fingerprint} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Bans.create_fingerprint()
|
||||
|
||||
fingerprint
|
||||
end
|
||||
|
||||
test "list_fingerprint_bans/0 returns all fingerprint_bans" do
|
||||
fingerprint = fingerprint_fixture()
|
||||
assert Bans.list_fingerprint_bans() == [fingerprint]
|
||||
end
|
||||
|
||||
test "get_fingerprint!/1 returns the fingerprint with given id" do
|
||||
fingerprint = fingerprint_fixture()
|
||||
assert Bans.get_fingerprint!(fingerprint.id) == fingerprint
|
||||
end
|
||||
|
||||
test "create_fingerprint/1 with valid data creates a fingerprint" do
|
||||
assert {:ok, %Fingerprint{} = fingerprint} = Bans.create_fingerprint(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_fingerprint/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Bans.create_fingerprint(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_fingerprint/2 with valid data updates the fingerprint" do
|
||||
fingerprint = fingerprint_fixture()
|
||||
|
||||
assert {:ok, %Fingerprint{} = fingerprint} =
|
||||
Bans.update_fingerprint(fingerprint, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_fingerprint/2 with invalid data returns error changeset" do
|
||||
fingerprint = fingerprint_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Bans.update_fingerprint(fingerprint, @invalid_attrs)
|
||||
assert fingerprint == Bans.get_fingerprint!(fingerprint.id)
|
||||
end
|
||||
|
||||
test "delete_fingerprint/1 deletes the fingerprint" do
|
||||
fingerprint = fingerprint_fixture()
|
||||
assert {:ok, %Fingerprint{}} = Bans.delete_fingerprint(fingerprint)
|
||||
assert_raise Ecto.NoResultsError, fn -> Bans.get_fingerprint!(fingerprint.id) end
|
||||
end
|
||||
|
||||
test "change_fingerprint/1 returns a fingerprint changeset" do
|
||||
fingerprint = fingerprint_fixture()
|
||||
assert %Ecto.Changeset{} = Bans.change_fingerprint(fingerprint)
|
||||
end
|
||||
end
|
||||
|
||||
describe "subnet_bans" do
|
||||
alias Philomena.Bans.Subnet
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def subnet_fixture(attrs \\ %{}) do
|
||||
{:ok, subnet} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Bans.create_subnet()
|
||||
|
||||
subnet
|
||||
end
|
||||
|
||||
test "list_subnet_bans/0 returns all subnet_bans" do
|
||||
subnet = subnet_fixture()
|
||||
assert Bans.list_subnet_bans() == [subnet]
|
||||
end
|
||||
|
||||
test "get_subnet!/1 returns the subnet with given id" do
|
||||
subnet = subnet_fixture()
|
||||
assert Bans.get_subnet!(subnet.id) == subnet
|
||||
end
|
||||
|
||||
test "create_subnet/1 with valid data creates a subnet" do
|
||||
assert {:ok, %Subnet{} = subnet} = Bans.create_subnet(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_subnet/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Bans.create_subnet(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_subnet/2 with valid data updates the subnet" do
|
||||
subnet = subnet_fixture()
|
||||
assert {:ok, %Subnet{} = subnet} = Bans.update_subnet(subnet, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_subnet/2 with invalid data returns error changeset" do
|
||||
subnet = subnet_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Bans.update_subnet(subnet, @invalid_attrs)
|
||||
assert subnet == Bans.get_subnet!(subnet.id)
|
||||
end
|
||||
|
||||
test "delete_subnet/1 deletes the subnet" do
|
||||
subnet = subnet_fixture()
|
||||
assert {:ok, %Subnet{}} = Bans.delete_subnet(subnet)
|
||||
assert_raise Ecto.NoResultsError, fn -> Bans.get_subnet!(subnet.id) end
|
||||
end
|
||||
|
||||
test "change_subnet/1 returns a subnet changeset" do
|
||||
subnet = subnet_fixture()
|
||||
assert %Ecto.Changeset{} = Bans.change_subnet(subnet)
|
||||
end
|
||||
end
|
||||
|
||||
describe "user_bans" do
|
||||
alias Philomena.Bans.User
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def user_fixture(attrs \\ %{}) do
|
||||
{:ok, user} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Bans.create_user()
|
||||
|
||||
user
|
||||
end
|
||||
|
||||
test "list_user_bans/0 returns all user_bans" do
|
||||
user = user_fixture()
|
||||
assert Bans.list_user_bans() == [user]
|
||||
end
|
||||
|
||||
test "get_user!/1 returns the user with given id" do
|
||||
user = user_fixture()
|
||||
assert Bans.get_user!(user.id) == user
|
||||
end
|
||||
|
||||
test "create_user/1 with valid data creates a user" do
|
||||
assert {:ok, %User{} = user} = Bans.create_user(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_user/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Bans.create_user(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_user/2 with valid data updates the user" do
|
||||
user = user_fixture()
|
||||
assert {:ok, %User{} = user} = Bans.update_user(user, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_user/2 with invalid data returns error changeset" do
|
||||
user = user_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Bans.update_user(user, @invalid_attrs)
|
||||
assert user == Bans.get_user!(user.id)
|
||||
end
|
||||
|
||||
test "delete_user/1 deletes the user" do
|
||||
user = user_fixture()
|
||||
assert {:ok, %User{}} = Bans.delete_user(user)
|
||||
assert_raise Ecto.NoResultsError, fn -> Bans.get_user!(user.id) end
|
||||
end
|
||||
|
||||
test "change_user/1 returns a user changeset" do
|
||||
user = user_fixture()
|
||||
assert %Ecto.Changeset{} = Bans.change_user(user)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,119 +0,0 @@
|
|||
defmodule Philomena.ChannelsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Channels
|
||||
|
||||
describe "channels" do
|
||||
alias Philomena.Channels.Channel
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def channel_fixture(attrs \\ %{}) do
|
||||
{:ok, channel} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Channels.create_channel()
|
||||
|
||||
channel
|
||||
end
|
||||
|
||||
test "list_channels/0 returns all channels" do
|
||||
channel = channel_fixture()
|
||||
assert Channels.list_channels() == [channel]
|
||||
end
|
||||
|
||||
test "get_channel!/1 returns the channel with given id" do
|
||||
channel = channel_fixture()
|
||||
assert Channels.get_channel!(channel.id) == channel
|
||||
end
|
||||
|
||||
test "create_channel/1 with valid data creates a channel" do
|
||||
assert {:ok, %Channel{} = channel} = Channels.create_channel(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_channel/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Channels.create_channel(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_channel/2 with valid data updates the channel" do
|
||||
channel = channel_fixture()
|
||||
assert {:ok, %Channel{} = channel} = Channels.update_channel(channel, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_channel/2 with invalid data returns error changeset" do
|
||||
channel = channel_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Channels.update_channel(channel, @invalid_attrs)
|
||||
assert channel == Channels.get_channel!(channel.id)
|
||||
end
|
||||
|
||||
test "delete_channel/1 deletes the channel" do
|
||||
channel = channel_fixture()
|
||||
assert {:ok, %Channel{}} = Channels.delete_channel(channel)
|
||||
assert_raise Ecto.NoResultsError, fn -> Channels.get_channel!(channel.id) end
|
||||
end
|
||||
|
||||
test "change_channel/1 returns a channel changeset" do
|
||||
channel = channel_fixture()
|
||||
assert %Ecto.Changeset{} = Channels.change_channel(channel)
|
||||
end
|
||||
end
|
||||
|
||||
describe "channel_subscriptions" do
|
||||
alias Philomena.Channels.Subscription
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def subscription_fixture(attrs \\ %{}) do
|
||||
{:ok, subscription} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Channels.create_subscription()
|
||||
|
||||
subscription
|
||||
end
|
||||
|
||||
test "list_channel_subscriptions/0 returns all channel_subscriptions" do
|
||||
subscription = subscription_fixture()
|
||||
assert Channels.list_channel_subscriptions() == [subscription]
|
||||
end
|
||||
|
||||
test "get_subscription!/1 returns the subscription with given id" do
|
||||
subscription = subscription_fixture()
|
||||
assert Channels.get_subscription!(subscription.id) == subscription
|
||||
end
|
||||
|
||||
test "create_subscription/1 with valid data creates a subscription" do
|
||||
assert {:ok, %Subscription{} = subscription} = Channels.create_subscription(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_subscription/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Channels.create_subscription(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with valid data updates the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
assert {:ok, %Subscription{} = subscription} = Channels.update_subscription(subscription, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with invalid data returns error changeset" do
|
||||
subscription = subscription_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Channels.update_subscription(subscription, @invalid_attrs)
|
||||
assert subscription == Channels.get_subscription!(subscription.id)
|
||||
end
|
||||
|
||||
test "delete_subscription/1 deletes the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
assert {:ok, %Subscription{}} = Channels.delete_subscription(subscription)
|
||||
assert_raise Ecto.NoResultsError, fn -> Channels.get_subscription!(subscription.id) end
|
||||
end
|
||||
|
||||
test "change_subscription/1 returns a subscription changeset" do
|
||||
subscription = subscription_fixture()
|
||||
assert %Ecto.Changeset{} = Channels.change_subscription(subscription)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.CommentsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Comments
|
||||
|
||||
describe "comments" do
|
||||
alias Philomena.Comments.Comment
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def comment_fixture(attrs \\ %{}) do
|
||||
{:ok, comment} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Comments.create_comment()
|
||||
|
||||
comment
|
||||
end
|
||||
|
||||
test "list_comments/0 returns all comments" do
|
||||
comment = comment_fixture()
|
||||
assert Comments.list_comments() == [comment]
|
||||
end
|
||||
|
||||
test "get_comment!/1 returns the comment with given id" do
|
||||
comment = comment_fixture()
|
||||
assert Comments.get_comment!(comment.id) == comment
|
||||
end
|
||||
|
||||
test "create_comment/1 with valid data creates a comment" do
|
||||
assert {:ok, %Comment{} = comment} = Comments.create_comment(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_comment/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Comments.create_comment(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_comment/2 with valid data updates the comment" do
|
||||
comment = comment_fixture()
|
||||
assert {:ok, %Comment{} = comment} = Comments.update_comment(comment, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_comment/2 with invalid data returns error changeset" do
|
||||
comment = comment_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Comments.update_comment(comment, @invalid_attrs)
|
||||
assert comment == Comments.get_comment!(comment.id)
|
||||
end
|
||||
|
||||
test "delete_comment/1 deletes the comment" do
|
||||
comment = comment_fixture()
|
||||
assert {:ok, %Comment{}} = Comments.delete_comment(comment)
|
||||
assert_raise Ecto.NoResultsError, fn -> Comments.get_comment!(comment.id) end
|
||||
end
|
||||
|
||||
test "change_comment/1 returns a comment changeset" do
|
||||
comment = comment_fixture()
|
||||
assert %Ecto.Changeset{} = Comments.change_comment(comment)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
defmodule Philomena.CommissionsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Commissions
|
||||
|
||||
describe "commissions" do
|
||||
alias Philomena.Commissions.Commission
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def commission_fixture(attrs \\ %{}) do
|
||||
{:ok, commission} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Commissions.create_commission()
|
||||
|
||||
commission
|
||||
end
|
||||
|
||||
test "list_commissions/0 returns all commissions" do
|
||||
commission = commission_fixture()
|
||||
assert Commissions.list_commissions() == [commission]
|
||||
end
|
||||
|
||||
test "get_commission!/1 returns the commission with given id" do
|
||||
commission = commission_fixture()
|
||||
assert Commissions.get_commission!(commission.id) == commission
|
||||
end
|
||||
|
||||
test "create_commission/1 with valid data creates a commission" do
|
||||
assert {:ok, %Commission{} = commission} = Commissions.create_commission(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_commission/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Commissions.create_commission(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_commission/2 with valid data updates the commission" do
|
||||
commission = commission_fixture()
|
||||
|
||||
assert {:ok, %Commission{} = commission} =
|
||||
Commissions.update_commission(commission, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_commission/2 with invalid data returns error changeset" do
|
||||
commission = commission_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Commissions.update_commission(commission, @invalid_attrs)
|
||||
|
||||
assert commission == Commissions.get_commission!(commission.id)
|
||||
end
|
||||
|
||||
test "delete_commission/1 deletes the commission" do
|
||||
commission = commission_fixture()
|
||||
assert {:ok, %Commission{}} = Commissions.delete_commission(commission)
|
||||
assert_raise Ecto.NoResultsError, fn -> Commissions.get_commission!(commission.id) end
|
||||
end
|
||||
|
||||
test "change_commission/1 returns a commission changeset" do
|
||||
commission = commission_fixture()
|
||||
assert %Ecto.Changeset{} = Commissions.change_commission(commission)
|
||||
end
|
||||
end
|
||||
|
||||
describe "commission_items" do
|
||||
alias Philomena.Commissions.Item
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def item_fixture(attrs \\ %{}) do
|
||||
{:ok, item} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Commissions.create_item()
|
||||
|
||||
item
|
||||
end
|
||||
|
||||
test "list_commission_items/0 returns all commission_items" do
|
||||
item = item_fixture()
|
||||
assert Commissions.list_commission_items() == [item]
|
||||
end
|
||||
|
||||
test "get_item!/1 returns the item with given id" do
|
||||
item = item_fixture()
|
||||
assert Commissions.get_item!(item.id) == item
|
||||
end
|
||||
|
||||
test "create_item/1 with valid data creates a item" do
|
||||
assert {:ok, %Item{} = item} = Commissions.create_item(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_item/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Commissions.create_item(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_item/2 with valid data updates the item" do
|
||||
item = item_fixture()
|
||||
assert {:ok, %Item{} = item} = Commissions.update_item(item, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_item/2 with invalid data returns error changeset" do
|
||||
item = item_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Commissions.update_item(item, @invalid_attrs)
|
||||
assert item == Commissions.get_item!(item.id)
|
||||
end
|
||||
|
||||
test "delete_item/1 deletes the item" do
|
||||
item = item_fixture()
|
||||
assert {:ok, %Item{}} = Commissions.delete_item(item)
|
||||
assert_raise Ecto.NoResultsError, fn -> Commissions.get_item!(item.id) end
|
||||
end
|
||||
|
||||
test "change_item/1 returns a item changeset" do
|
||||
item = item_fixture()
|
||||
assert %Ecto.Changeset{} = Commissions.change_item(item)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,125 +0,0 @@
|
|||
defmodule Philomena.ConversationsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Conversations
|
||||
|
||||
describe "conversations" do
|
||||
alias Philomena.Conversations.Conversation
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def conversation_fixture(attrs \\ %{}) do
|
||||
{:ok, conversation} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Conversations.create_conversation()
|
||||
|
||||
conversation
|
||||
end
|
||||
|
||||
test "list_conversations/0 returns all conversations" do
|
||||
conversation = conversation_fixture()
|
||||
assert Conversations.list_conversations() == [conversation]
|
||||
end
|
||||
|
||||
test "get_conversation!/1 returns the conversation with given id" do
|
||||
conversation = conversation_fixture()
|
||||
assert Conversations.get_conversation!(conversation.id) == conversation
|
||||
end
|
||||
|
||||
test "create_conversation/1 with valid data creates a conversation" do
|
||||
assert {:ok, %Conversation{} = conversation} =
|
||||
Conversations.create_conversation(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_conversation/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Conversations.create_conversation(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_conversation/2 with valid data updates the conversation" do
|
||||
conversation = conversation_fixture()
|
||||
|
||||
assert {:ok, %Conversation{} = conversation} =
|
||||
Conversations.update_conversation(conversation, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_conversation/2 with invalid data returns error changeset" do
|
||||
conversation = conversation_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Conversations.update_conversation(conversation, @invalid_attrs)
|
||||
|
||||
assert conversation == Conversations.get_conversation!(conversation.id)
|
||||
end
|
||||
|
||||
test "delete_conversation/1 deletes the conversation" do
|
||||
conversation = conversation_fixture()
|
||||
assert {:ok, %Conversation{}} = Conversations.delete_conversation(conversation)
|
||||
assert_raise Ecto.NoResultsError, fn -> Conversations.get_conversation!(conversation.id) end
|
||||
end
|
||||
|
||||
test "change_conversation/1 returns a conversation changeset" do
|
||||
conversation = conversation_fixture()
|
||||
assert %Ecto.Changeset{} = Conversations.change_conversation(conversation)
|
||||
end
|
||||
end
|
||||
|
||||
describe "messages" do
|
||||
alias Philomena.Conversations.Message
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def message_fixture(attrs \\ %{}) do
|
||||
{:ok, message} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Conversations.create_message()
|
||||
|
||||
message
|
||||
end
|
||||
|
||||
test "list_messages/0 returns all messages" do
|
||||
message = message_fixture()
|
||||
assert Conversations.list_messages() == [message]
|
||||
end
|
||||
|
||||
test "get_message!/1 returns the message with given id" do
|
||||
message = message_fixture()
|
||||
assert Conversations.get_message!(message.id) == message
|
||||
end
|
||||
|
||||
test "create_message/1 with valid data creates a message" do
|
||||
assert {:ok, %Message{} = message} = Conversations.create_message(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_message/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Conversations.create_message(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_message/2 with valid data updates the message" do
|
||||
message = message_fixture()
|
||||
assert {:ok, %Message{} = message} = Conversations.update_message(message, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_message/2 with invalid data returns error changeset" do
|
||||
message = message_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Conversations.update_message(message, @invalid_attrs)
|
||||
assert message == Conversations.get_message!(message.id)
|
||||
end
|
||||
|
||||
test "delete_message/1 deletes the message" do
|
||||
message = message_fixture()
|
||||
assert {:ok, %Message{}} = Conversations.delete_message(message)
|
||||
assert_raise Ecto.NoResultsError, fn -> Conversations.get_message!(message.id) end
|
||||
end
|
||||
|
||||
test "change_message/1 returns a message changeset" do
|
||||
message = message_fixture()
|
||||
assert %Ecto.Changeset{} = Conversations.change_message(message)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
defmodule Philomena.DnpEntriesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.DnpEntries
|
||||
|
||||
describe "dnp_entries" do
|
||||
alias Philomena.DnpEntries.DnpEntry
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def dnp_entry_fixture(attrs \\ %{}) do
|
||||
{:ok, dnp_entry} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> DnpEntries.create_dnp_entry()
|
||||
|
||||
dnp_entry
|
||||
end
|
||||
|
||||
test "list_dnp_entries/0 returns all dnp_entries" do
|
||||
dnp_entry = dnp_entry_fixture()
|
||||
assert DnpEntries.list_dnp_entries() == [dnp_entry]
|
||||
end
|
||||
|
||||
test "get_dnp_entry!/1 returns the dnp_entry with given id" do
|
||||
dnp_entry = dnp_entry_fixture()
|
||||
assert DnpEntries.get_dnp_entry!(dnp_entry.id) == dnp_entry
|
||||
end
|
||||
|
||||
test "create_dnp_entry/1 with valid data creates a dnp_entry" do
|
||||
assert {:ok, %DnpEntry{} = dnp_entry} = DnpEntries.create_dnp_entry(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_dnp_entry/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = DnpEntries.create_dnp_entry(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_dnp_entry/2 with valid data updates the dnp_entry" do
|
||||
dnp_entry = dnp_entry_fixture()
|
||||
|
||||
assert {:ok, %DnpEntry{} = dnp_entry} =
|
||||
DnpEntries.update_dnp_entry(dnp_entry, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_dnp_entry/2 with invalid data returns error changeset" do
|
||||
dnp_entry = dnp_entry_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = DnpEntries.update_dnp_entry(dnp_entry, @invalid_attrs)
|
||||
assert dnp_entry == DnpEntries.get_dnp_entry!(dnp_entry.id)
|
||||
end
|
||||
|
||||
test "delete_dnp_entry/1 deletes the dnp_entry" do
|
||||
dnp_entry = dnp_entry_fixture()
|
||||
assert {:ok, %DnpEntry{}} = DnpEntries.delete_dnp_entry(dnp_entry)
|
||||
assert_raise Ecto.NoResultsError, fn -> DnpEntries.get_dnp_entry!(dnp_entry.id) end
|
||||
end
|
||||
|
||||
test "change_dnp_entry/1 returns a dnp_entry changeset" do
|
||||
dnp_entry = dnp_entry_fixture()
|
||||
assert %Ecto.Changeset{} = DnpEntries.change_dnp_entry(dnp_entry)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.DonationsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Donations
|
||||
|
||||
describe "donations" do
|
||||
alias Philomena.Donations.Donation
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def donation_fixture(attrs \\ %{}) do
|
||||
{:ok, donation} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Donations.create_donation()
|
||||
|
||||
donation
|
||||
end
|
||||
|
||||
test "list_donations/0 returns all donations" do
|
||||
donation = donation_fixture()
|
||||
assert Donations.list_donations() == [donation]
|
||||
end
|
||||
|
||||
test "get_donation!/1 returns the donation with given id" do
|
||||
donation = donation_fixture()
|
||||
assert Donations.get_donation!(donation.id) == donation
|
||||
end
|
||||
|
||||
test "create_donation/1 with valid data creates a donation" do
|
||||
assert {:ok, %Donation{} = donation} = Donations.create_donation(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_donation/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Donations.create_donation(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_donation/2 with valid data updates the donation" do
|
||||
donation = donation_fixture()
|
||||
assert {:ok, %Donation{} = donation} = Donations.update_donation(donation, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_donation/2 with invalid data returns error changeset" do
|
||||
donation = donation_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Donations.update_donation(donation, @invalid_attrs)
|
||||
assert donation == Donations.get_donation!(donation.id)
|
||||
end
|
||||
|
||||
test "delete_donation/1 deletes the donation" do
|
||||
donation = donation_fixture()
|
||||
assert {:ok, %Donation{}} = Donations.delete_donation(donation)
|
||||
assert_raise Ecto.NoResultsError, fn -> Donations.get_donation!(donation.id) end
|
||||
end
|
||||
|
||||
test "change_donation/1 returns a donation changeset" do
|
||||
donation = donation_fixture()
|
||||
assert %Ecto.Changeset{} = Donations.change_donation(donation)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
defmodule Philomena.DuplicateReportsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.DuplicateReports
|
||||
|
||||
describe "duplicate_reports" do
|
||||
alias Philomena.DuplicateReports.DuplicateReport
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def duplicate_report_fixture(attrs \\ %{}) do
|
||||
{:ok, duplicate_report} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> DuplicateReports.create_duplicate_report()
|
||||
|
||||
duplicate_report
|
||||
end
|
||||
|
||||
test "list_duplicate_reports/0 returns all duplicate_reports" do
|
||||
duplicate_report = duplicate_report_fixture()
|
||||
assert DuplicateReports.list_duplicate_reports() == [duplicate_report]
|
||||
end
|
||||
|
||||
test "get_duplicate_report!/1 returns the duplicate_report with given id" do
|
||||
duplicate_report = duplicate_report_fixture()
|
||||
assert DuplicateReports.get_duplicate_report!(duplicate_report.id) == duplicate_report
|
||||
end
|
||||
|
||||
test "create_duplicate_report/1 with valid data creates a duplicate_report" do
|
||||
assert {:ok, %DuplicateReport{} = duplicate_report} =
|
||||
DuplicateReports.create_duplicate_report(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_duplicate_report/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
DuplicateReports.create_duplicate_report(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_duplicate_report/2 with valid data updates the duplicate_report" do
|
||||
duplicate_report = duplicate_report_fixture()
|
||||
|
||||
assert {:ok, %DuplicateReport{} = duplicate_report} =
|
||||
DuplicateReports.update_duplicate_report(duplicate_report, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_duplicate_report/2 with invalid data returns error changeset" do
|
||||
duplicate_report = duplicate_report_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
DuplicateReports.update_duplicate_report(duplicate_report, @invalid_attrs)
|
||||
|
||||
assert duplicate_report == DuplicateReports.get_duplicate_report!(duplicate_report.id)
|
||||
end
|
||||
|
||||
test "delete_duplicate_report/1 deletes the duplicate_report" do
|
||||
duplicate_report = duplicate_report_fixture()
|
||||
|
||||
assert {:ok, %DuplicateReport{}} =
|
||||
DuplicateReports.delete_duplicate_report(duplicate_report)
|
||||
|
||||
assert_raise Ecto.NoResultsError, fn ->
|
||||
DuplicateReports.get_duplicate_report!(duplicate_report.id)
|
||||
end
|
||||
end
|
||||
|
||||
test "change_duplicate_report/1 returns a duplicate_report changeset" do
|
||||
duplicate_report = duplicate_report_fixture()
|
||||
assert %Ecto.Changeset{} = DuplicateReports.change_duplicate_report(duplicate_report)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.FiltersTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Filters
|
||||
|
||||
describe "filters" do
|
||||
alias Philomena.Filters.Filter
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def filter_fixture(attrs \\ %{}) do
|
||||
{:ok, filter} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Filters.create_filter()
|
||||
|
||||
filter
|
||||
end
|
||||
|
||||
test "list_filters/0 returns all filters" do
|
||||
filter = filter_fixture()
|
||||
assert Filters.list_filters() == [filter]
|
||||
end
|
||||
|
||||
test "get_filter!/1 returns the filter with given id" do
|
||||
filter = filter_fixture()
|
||||
assert Filters.get_filter!(filter.id) == filter
|
||||
end
|
||||
|
||||
test "create_filter/1 with valid data creates a filter" do
|
||||
assert {:ok, %Filter{} = filter} = Filters.create_filter(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_filter/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Filters.create_filter(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_filter/2 with valid data updates the filter" do
|
||||
filter = filter_fixture()
|
||||
assert {:ok, %Filter{} = filter} = Filters.update_filter(filter, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_filter/2 with invalid data returns error changeset" do
|
||||
filter = filter_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Filters.update_filter(filter, @invalid_attrs)
|
||||
assert filter == Filters.get_filter!(filter.id)
|
||||
end
|
||||
|
||||
test "delete_filter/1 deletes the filter" do
|
||||
filter = filter_fixture()
|
||||
assert {:ok, %Filter{}} = Filters.delete_filter(filter)
|
||||
assert_raise Ecto.NoResultsError, fn -> Filters.get_filter!(filter.id) end
|
||||
end
|
||||
|
||||
test "change_filter/1 returns a filter changeset" do
|
||||
filter = filter_fixture()
|
||||
assert %Ecto.Changeset{} = Filters.change_filter(filter)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,418 +0,0 @@
|
|||
defmodule Philomena.ForumsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Forums
|
||||
|
||||
describe "forums" do
|
||||
alias Philomena.Forums.Forum
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def forum_fixture(attrs \\ %{}) do
|
||||
{:ok, forum} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Forums.create_forum()
|
||||
|
||||
forum
|
||||
end
|
||||
|
||||
test "list_forums/0 returns all forums" do
|
||||
forum = forum_fixture()
|
||||
assert Forums.list_forums() == [forum]
|
||||
end
|
||||
|
||||
test "get_forum!/1 returns the forum with given id" do
|
||||
forum = forum_fixture()
|
||||
assert Forums.get_forum!(forum.id) == forum
|
||||
end
|
||||
|
||||
test "create_forum/1 with valid data creates a forum" do
|
||||
assert {:ok, %Forum{} = forum} = Forums.create_forum(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_forum/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.create_forum(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_forum/2 with valid data updates the forum" do
|
||||
forum = forum_fixture()
|
||||
assert {:ok, %Forum{} = forum} = Forums.update_forum(forum, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_forum/2 with invalid data returns error changeset" do
|
||||
forum = forum_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.update_forum(forum, @invalid_attrs)
|
||||
assert forum == Forums.get_forum!(forum.id)
|
||||
end
|
||||
|
||||
test "delete_forum/1 deletes the forum" do
|
||||
forum = forum_fixture()
|
||||
assert {:ok, %Forum{}} = Forums.delete_forum(forum)
|
||||
assert_raise Ecto.NoResultsError, fn -> Forums.get_forum!(forum.id) end
|
||||
end
|
||||
|
||||
test "change_forum/1 returns a forum changeset" do
|
||||
forum = forum_fixture()
|
||||
assert %Ecto.Changeset{} = Forums.change_forum(forum)
|
||||
end
|
||||
end
|
||||
|
||||
describe "topics" do
|
||||
alias Philomena.Forums.Topic
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def topic_fixture(attrs \\ %{}) do
|
||||
{:ok, topic} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Forums.create_topic()
|
||||
|
||||
topic
|
||||
end
|
||||
|
||||
test "list_topics/0 returns all topics" do
|
||||
topic = topic_fixture()
|
||||
assert Forums.list_topics() == [topic]
|
||||
end
|
||||
|
||||
test "get_topic!/1 returns the topic with given id" do
|
||||
topic = topic_fixture()
|
||||
assert Forums.get_topic!(topic.id) == topic
|
||||
end
|
||||
|
||||
test "create_topic/1 with valid data creates a topic" do
|
||||
assert {:ok, %Topic{} = topic} = Forums.create_topic(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_topic/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.create_topic(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_topic/2 with valid data updates the topic" do
|
||||
topic = topic_fixture()
|
||||
assert {:ok, %Topic{} = topic} = Forums.update_topic(topic, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_topic/2 with invalid data returns error changeset" do
|
||||
topic = topic_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.update_topic(topic, @invalid_attrs)
|
||||
assert topic == Forums.get_topic!(topic.id)
|
||||
end
|
||||
|
||||
test "delete_topic/1 deletes the topic" do
|
||||
topic = topic_fixture()
|
||||
assert {:ok, %Topic{}} = Forums.delete_topic(topic)
|
||||
assert_raise Ecto.NoResultsError, fn -> Forums.get_topic!(topic.id) end
|
||||
end
|
||||
|
||||
test "change_topic/1 returns a topic changeset" do
|
||||
topic = topic_fixture()
|
||||
assert %Ecto.Changeset{} = Forums.change_topic(topic)
|
||||
end
|
||||
end
|
||||
|
||||
describe "posts" do
|
||||
alias Philomena.Forums.Post
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def post_fixture(attrs \\ %{}) do
|
||||
{:ok, post} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Forums.create_post()
|
||||
|
||||
post
|
||||
end
|
||||
|
||||
test "list_posts/0 returns all posts" do
|
||||
post = post_fixture()
|
||||
assert Forums.list_posts() == [post]
|
||||
end
|
||||
|
||||
test "get_post!/1 returns the post with given id" do
|
||||
post = post_fixture()
|
||||
assert Forums.get_post!(post.id) == post
|
||||
end
|
||||
|
||||
test "create_post/1 with valid data creates a post" do
|
||||
assert {:ok, %Post{} = post} = Forums.create_post(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_post/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.create_post(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_post/2 with valid data updates the post" do
|
||||
post = post_fixture()
|
||||
assert {:ok, %Post{} = post} = Forums.update_post(post, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_post/2 with invalid data returns error changeset" do
|
||||
post = post_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.update_post(post, @invalid_attrs)
|
||||
assert post == Forums.get_post!(post.id)
|
||||
end
|
||||
|
||||
test "delete_post/1 deletes the post" do
|
||||
post = post_fixture()
|
||||
assert {:ok, %Post{}} = Forums.delete_post(post)
|
||||
assert_raise Ecto.NoResultsError, fn -> Forums.get_post!(post.id) end
|
||||
end
|
||||
|
||||
test "change_post/1 returns a post changeset" do
|
||||
post = post_fixture()
|
||||
assert %Ecto.Changeset{} = Forums.change_post(post)
|
||||
end
|
||||
end
|
||||
|
||||
describe "forum_subscriptions" do
|
||||
alias Philomena.Forums.Subscription
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def subscription_fixture(attrs \\ %{}) do
|
||||
{:ok, subscription} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Forums.create_subscription()
|
||||
|
||||
subscription
|
||||
end
|
||||
|
||||
test "list_forum_subscriptions/0 returns all forum_subscriptions" do
|
||||
subscription = subscription_fixture()
|
||||
assert Forums.list_forum_subscriptions() == [subscription]
|
||||
end
|
||||
|
||||
test "get_subscription!/1 returns the subscription with given id" do
|
||||
subscription = subscription_fixture()
|
||||
assert Forums.get_subscription!(subscription.id) == subscription
|
||||
end
|
||||
|
||||
test "create_subscription/1 with valid data creates a subscription" do
|
||||
assert {:ok, %Subscription{} = subscription} = Forums.create_subscription(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_subscription/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.create_subscription(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with valid data updates the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
|
||||
assert {:ok, %Subscription{} = subscription} =
|
||||
Forums.update_subscription(subscription, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with invalid data returns error changeset" do
|
||||
subscription = subscription_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Forums.update_subscription(subscription, @invalid_attrs)
|
||||
|
||||
assert subscription == Forums.get_subscription!(subscription.id)
|
||||
end
|
||||
|
||||
test "delete_subscription/1 deletes the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
assert {:ok, %Subscription{}} = Forums.delete_subscription(subscription)
|
||||
assert_raise Ecto.NoResultsError, fn -> Forums.get_subscription!(subscription.id) end
|
||||
end
|
||||
|
||||
test "change_subscription/1 returns a subscription changeset" do
|
||||
subscription = subscription_fixture()
|
||||
assert %Ecto.Changeset{} = Forums.change_subscription(subscription)
|
||||
end
|
||||
end
|
||||
|
||||
describe "polls" do
|
||||
alias Philomena.Forums.Polls
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def polls_fixture(attrs \\ %{}) do
|
||||
{:ok, polls} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Forums.create_polls()
|
||||
|
||||
polls
|
||||
end
|
||||
|
||||
test "list_polls/0 returns all polls" do
|
||||
polls = polls_fixture()
|
||||
assert Forums.list_polls() == [polls]
|
||||
end
|
||||
|
||||
test "get_polls!/1 returns the polls with given id" do
|
||||
polls = polls_fixture()
|
||||
assert Forums.get_polls!(polls.id) == polls
|
||||
end
|
||||
|
||||
test "create_polls/1 with valid data creates a polls" do
|
||||
assert {:ok, %Polls{} = polls} = Forums.create_polls(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_polls/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.create_polls(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_polls/2 with valid data updates the polls" do
|
||||
polls = polls_fixture()
|
||||
assert {:ok, %Polls{} = polls} = Forums.update_polls(polls, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_polls/2 with invalid data returns error changeset" do
|
||||
polls = polls_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.update_polls(polls, @invalid_attrs)
|
||||
assert polls == Forums.get_polls!(polls.id)
|
||||
end
|
||||
|
||||
test "delete_polls/1 deletes the polls" do
|
||||
polls = polls_fixture()
|
||||
assert {:ok, %Polls{}} = Forums.delete_polls(polls)
|
||||
assert_raise Ecto.NoResultsError, fn -> Forums.get_polls!(polls.id) end
|
||||
end
|
||||
|
||||
test "change_polls/1 returns a polls changeset" do
|
||||
polls = polls_fixture()
|
||||
assert %Ecto.Changeset{} = Forums.change_polls(polls)
|
||||
end
|
||||
end
|
||||
|
||||
describe "poll_votes" do
|
||||
alias Philomena.Forums.PollVote
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def poll_vote_fixture(attrs \\ %{}) do
|
||||
{:ok, poll_vote} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Forums.create_poll_vote()
|
||||
|
||||
poll_vote
|
||||
end
|
||||
|
||||
test "list_poll_votes/0 returns all poll_votes" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert Forums.list_poll_votes() == [poll_vote]
|
||||
end
|
||||
|
||||
test "get_poll_vote!/1 returns the poll_vote with given id" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert Forums.get_poll_vote!(poll_vote.id) == poll_vote
|
||||
end
|
||||
|
||||
test "create_poll_vote/1 with valid data creates a poll_vote" do
|
||||
assert {:ok, %PollVote{} = poll_vote} = Forums.create_poll_vote(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_poll_vote/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.create_poll_vote(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_poll_vote/2 with valid data updates the poll_vote" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert {:ok, %PollVote{} = poll_vote} = Forums.update_poll_vote(poll_vote, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_poll_vote/2 with invalid data returns error changeset" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.update_poll_vote(poll_vote, @invalid_attrs)
|
||||
assert poll_vote == Forums.get_poll_vote!(poll_vote.id)
|
||||
end
|
||||
|
||||
test "delete_poll_vote/1 deletes the poll_vote" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert {:ok, %PollVote{}} = Forums.delete_poll_vote(poll_vote)
|
||||
assert_raise Ecto.NoResultsError, fn -> Forums.get_poll_vote!(poll_vote.id) end
|
||||
end
|
||||
|
||||
test "change_poll_vote/1 returns a poll_vote changeset" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert %Ecto.Changeset{} = Forums.change_poll_vote(poll_vote)
|
||||
end
|
||||
end
|
||||
|
||||
describe "topic_subscriptions" do
|
||||
alias Philomena.Forums.TopicSubscription
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def topic_subscription_fixture(attrs \\ %{}) do
|
||||
{:ok, topic_subscription} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Forums.create_topic_subscription()
|
||||
|
||||
topic_subscription
|
||||
end
|
||||
|
||||
test "list_topic_subscriptions/0 returns all topic_subscriptions" do
|
||||
topic_subscription = topic_subscription_fixture()
|
||||
assert Forums.list_topic_subscriptions() == [topic_subscription]
|
||||
end
|
||||
|
||||
test "get_topic_subscription!/1 returns the topic_subscription with given id" do
|
||||
topic_subscription = topic_subscription_fixture()
|
||||
assert Forums.get_topic_subscription!(topic_subscription.id) == topic_subscription
|
||||
end
|
||||
|
||||
test "create_topic_subscription/1 with valid data creates a topic_subscription" do
|
||||
assert {:ok, %TopicSubscription{} = topic_subscription} =
|
||||
Forums.create_topic_subscription(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_topic_subscription/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Forums.create_topic_subscription(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_topic_subscription/2 with valid data updates the topic_subscription" do
|
||||
topic_subscription = topic_subscription_fixture()
|
||||
|
||||
assert {:ok, %TopicSubscription{} = topic_subscription} =
|
||||
Forums.update_topic_subscription(topic_subscription, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_topic_subscription/2 with invalid data returns error changeset" do
|
||||
topic_subscription = topic_subscription_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Forums.update_topic_subscription(topic_subscription, @invalid_attrs)
|
||||
|
||||
assert topic_subscription == Forums.get_topic_subscription!(topic_subscription.id)
|
||||
end
|
||||
|
||||
test "delete_topic_subscription/1 deletes the topic_subscription" do
|
||||
topic_subscription = topic_subscription_fixture()
|
||||
assert {:ok, %TopicSubscription{}} = Forums.delete_topic_subscription(topic_subscription)
|
||||
|
||||
assert_raise Ecto.NoResultsError, fn ->
|
||||
Forums.get_topic_subscription!(topic_subscription.id)
|
||||
end
|
||||
end
|
||||
|
||||
test "change_topic_subscription/1 returns a topic_subscription changeset" do
|
||||
topic_subscription = topic_subscription_fixture()
|
||||
assert %Ecto.Changeset{} = Forums.change_topic_subscription(topic_subscription)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
defmodule Philomena.GalleriesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Galleries
|
||||
|
||||
describe "galleries" do
|
||||
alias Philomena.Galleries.Gallery
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def gallery_fixture(attrs \\ %{}) do
|
||||
{:ok, gallery} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Galleries.create_gallery()
|
||||
|
||||
gallery
|
||||
end
|
||||
|
||||
test "list_galleries/0 returns all galleries" do
|
||||
gallery = gallery_fixture()
|
||||
assert Galleries.list_galleries() == [gallery]
|
||||
end
|
||||
|
||||
test "get_gallery!/1 returns the gallery with given id" do
|
||||
gallery = gallery_fixture()
|
||||
assert Galleries.get_gallery!(gallery.id) == gallery
|
||||
end
|
||||
|
||||
test "create_gallery/1 with valid data creates a gallery" do
|
||||
assert {:ok, %Gallery{} = gallery} = Galleries.create_gallery(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_gallery/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Galleries.create_gallery(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_gallery/2 with valid data updates the gallery" do
|
||||
gallery = gallery_fixture()
|
||||
assert {:ok, %Gallery{} = gallery} = Galleries.update_gallery(gallery, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_gallery/2 with invalid data returns error changeset" do
|
||||
gallery = gallery_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Galleries.update_gallery(gallery, @invalid_attrs)
|
||||
assert gallery == Galleries.get_gallery!(gallery.id)
|
||||
end
|
||||
|
||||
test "delete_gallery/1 deletes the gallery" do
|
||||
gallery = gallery_fixture()
|
||||
assert {:ok, %Gallery{}} = Galleries.delete_gallery(gallery)
|
||||
assert_raise Ecto.NoResultsError, fn -> Galleries.get_gallery!(gallery.id) end
|
||||
end
|
||||
|
||||
test "change_gallery/1 returns a gallery changeset" do
|
||||
gallery = gallery_fixture()
|
||||
assert %Ecto.Changeset{} = Galleries.change_gallery(gallery)
|
||||
end
|
||||
end
|
||||
|
||||
describe "gallery_subscriptions" do
|
||||
alias Philomena.Galleries.Subscription
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def subscription_fixture(attrs \\ %{}) do
|
||||
{:ok, subscription} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Galleries.create_subscription()
|
||||
|
||||
subscription
|
||||
end
|
||||
|
||||
test "list_gallery_subscriptions/0 returns all gallery_subscriptions" do
|
||||
subscription = subscription_fixture()
|
||||
assert Galleries.list_gallery_subscriptions() == [subscription]
|
||||
end
|
||||
|
||||
test "get_subscription!/1 returns the subscription with given id" do
|
||||
subscription = subscription_fixture()
|
||||
assert Galleries.get_subscription!(subscription.id) == subscription
|
||||
end
|
||||
|
||||
test "create_subscription/1 with valid data creates a subscription" do
|
||||
assert {:ok, %Subscription{} = subscription} = Galleries.create_subscription(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_subscription/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Galleries.create_subscription(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with valid data updates the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
|
||||
assert {:ok, %Subscription{} = subscription} =
|
||||
Galleries.update_subscription(subscription, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with invalid data returns error changeset" do
|
||||
subscription = subscription_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Galleries.update_subscription(subscription, @invalid_attrs)
|
||||
|
||||
assert subscription == Galleries.get_subscription!(subscription.id)
|
||||
end
|
||||
|
||||
test "delete_subscription/1 deletes the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
assert {:ok, %Subscription{}} = Galleries.delete_subscription(subscription)
|
||||
assert_raise Ecto.NoResultsError, fn -> Galleries.get_subscription!(subscription.id) end
|
||||
end
|
||||
|
||||
test "change_subscription/1 returns a subscription changeset" do
|
||||
subscription = subscription_fixture()
|
||||
assert %Ecto.Changeset{} = Galleries.change_subscription(subscription)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.ImageFavesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.ImageFaves
|
||||
|
||||
describe "image_faves" do
|
||||
alias Philomena.ImageFaves.ImageFave
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def image_fave_fixture(attrs \\ %{}) do
|
||||
{:ok, image_fave} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> ImageFaves.create_image_fave()
|
||||
|
||||
image_fave
|
||||
end
|
||||
|
||||
test "list_image_faves/0 returns all image_faves" do
|
||||
image_fave = image_fave_fixture()
|
||||
assert ImageFaves.list_image_faves() == [image_fave]
|
||||
end
|
||||
|
||||
test "get_image_fave!/1 returns the image_fave with given id" do
|
||||
image_fave = image_fave_fixture()
|
||||
assert ImageFaves.get_image_fave!(image_fave.id) == image_fave
|
||||
end
|
||||
|
||||
test "create_image_fave/1 with valid data creates a image_fave" do
|
||||
assert {:ok, %ImageFave{} = image_fave} = ImageFaves.create_image_fave(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_image_fave/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = ImageFaves.create_image_fave(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_image_fave/2 with valid data updates the image_fave" do
|
||||
image_fave = image_fave_fixture()
|
||||
assert {:ok, %ImageFave{} = image_fave} = ImageFaves.update_image_fave(image_fave, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_image_fave/2 with invalid data returns error changeset" do
|
||||
image_fave = image_fave_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = ImageFaves.update_image_fave(image_fave, @invalid_attrs)
|
||||
assert image_fave == ImageFaves.get_image_fave!(image_fave.id)
|
||||
end
|
||||
|
||||
test "delete_image_fave/1 deletes the image_fave" do
|
||||
image_fave = image_fave_fixture()
|
||||
assert {:ok, %ImageFave{}} = ImageFaves.delete_image_fave(image_fave)
|
||||
assert_raise Ecto.NoResultsError, fn -> ImageFaves.get_image_fave!(image_fave.id) end
|
||||
end
|
||||
|
||||
test "change_image_fave/1 returns a image_fave changeset" do
|
||||
image_fave = image_fave_fixture()
|
||||
assert %Ecto.Changeset{} = ImageFaves.change_image_fave(image_fave)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.ImageFeaturesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.ImageFeatures
|
||||
|
||||
describe "image_features" do
|
||||
alias Philomena.ImageFeatures.ImageFeature
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def image_feature_fixture(attrs \\ %{}) do
|
||||
{:ok, image_feature} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> ImageFeatures.create_image_feature()
|
||||
|
||||
image_feature
|
||||
end
|
||||
|
||||
test "list_image_features/0 returns all image_features" do
|
||||
image_feature = image_feature_fixture()
|
||||
assert ImageFeatures.list_image_features() == [image_feature]
|
||||
end
|
||||
|
||||
test "get_image_feature!/1 returns the image_feature with given id" do
|
||||
image_feature = image_feature_fixture()
|
||||
assert ImageFeatures.get_image_feature!(image_feature.id) == image_feature
|
||||
end
|
||||
|
||||
test "create_image_feature/1 with valid data creates a image_feature" do
|
||||
assert {:ok, %ImageFeature{} = image_feature} = ImageFeatures.create_image_feature(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_image_feature/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = ImageFeatures.create_image_feature(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_image_feature/2 with valid data updates the image_feature" do
|
||||
image_feature = image_feature_fixture()
|
||||
assert {:ok, %ImageFeature{} = image_feature} = ImageFeatures.update_image_feature(image_feature, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_image_feature/2 with invalid data returns error changeset" do
|
||||
image_feature = image_feature_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = ImageFeatures.update_image_feature(image_feature, @invalid_attrs)
|
||||
assert image_feature == ImageFeatures.get_image_feature!(image_feature.id)
|
||||
end
|
||||
|
||||
test "delete_image_feature/1 deletes the image_feature" do
|
||||
image_feature = image_feature_fixture()
|
||||
assert {:ok, %ImageFeature{}} = ImageFeatures.delete_image_feature(image_feature)
|
||||
assert_raise Ecto.NoResultsError, fn -> ImageFeatures.get_image_feature!(image_feature.id) end
|
||||
end
|
||||
|
||||
test "change_image_feature/1 returns a image_feature changeset" do
|
||||
image_feature = image_feature_fixture()
|
||||
assert %Ecto.Changeset{} = ImageFeatures.change_image_feature(image_feature)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.ImageHidesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.ImageHides
|
||||
|
||||
describe "image_hides" do
|
||||
alias Philomena.ImageHides.ImageHide
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def image_hide_fixture(attrs \\ %{}) do
|
||||
{:ok, image_hide} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> ImageHides.create_image_hide()
|
||||
|
||||
image_hide
|
||||
end
|
||||
|
||||
test "list_image_hides/0 returns all image_hides" do
|
||||
image_hide = image_hide_fixture()
|
||||
assert ImageHides.list_image_hides() == [image_hide]
|
||||
end
|
||||
|
||||
test "get_image_hide!/1 returns the image_hide with given id" do
|
||||
image_hide = image_hide_fixture()
|
||||
assert ImageHides.get_image_hide!(image_hide.id) == image_hide
|
||||
end
|
||||
|
||||
test "create_image_hide/1 with valid data creates a image_hide" do
|
||||
assert {:ok, %ImageHide{} = image_hide} = ImageHides.create_image_hide(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_image_hide/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = ImageHides.create_image_hide(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_image_hide/2 with valid data updates the image_hide" do
|
||||
image_hide = image_hide_fixture()
|
||||
assert {:ok, %ImageHide{} = image_hide} = ImageHides.update_image_hide(image_hide, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_image_hide/2 with invalid data returns error changeset" do
|
||||
image_hide = image_hide_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = ImageHides.update_image_hide(image_hide, @invalid_attrs)
|
||||
assert image_hide == ImageHides.get_image_hide!(image_hide.id)
|
||||
end
|
||||
|
||||
test "delete_image_hide/1 deletes the image_hide" do
|
||||
image_hide = image_hide_fixture()
|
||||
assert {:ok, %ImageHide{}} = ImageHides.delete_image_hide(image_hide)
|
||||
assert_raise Ecto.NoResultsError, fn -> ImageHides.get_image_hide!(image_hide.id) end
|
||||
end
|
||||
|
||||
test "change_image_hide/1 returns a image_hide changeset" do
|
||||
image_hide = image_hide_fixture()
|
||||
assert %Ecto.Changeset{} = ImageHides.change_image_hide(image_hide)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.ImageIntensitiesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.ImageIntensities
|
||||
|
||||
describe "image_intensities" do
|
||||
alias Philomena.ImageIntensities.ImageIntensity
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def image_intensity_fixture(attrs \\ %{}) do
|
||||
{:ok, image_intensity} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> ImageIntensities.create_image_intensity()
|
||||
|
||||
image_intensity
|
||||
end
|
||||
|
||||
test "list_image_intensities/0 returns all image_intensities" do
|
||||
image_intensity = image_intensity_fixture()
|
||||
assert ImageIntensities.list_image_intensities() == [image_intensity]
|
||||
end
|
||||
|
||||
test "get_image_intensity!/1 returns the image_intensity with given id" do
|
||||
image_intensity = image_intensity_fixture()
|
||||
assert ImageIntensities.get_image_intensity!(image_intensity.id) == image_intensity
|
||||
end
|
||||
|
||||
test "create_image_intensity/1 with valid data creates a image_intensity" do
|
||||
assert {:ok, %ImageIntensity{} = image_intensity} = ImageIntensities.create_image_intensity(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_image_intensity/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = ImageIntensities.create_image_intensity(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_image_intensity/2 with valid data updates the image_intensity" do
|
||||
image_intensity = image_intensity_fixture()
|
||||
assert {:ok, %ImageIntensity{} = image_intensity} = ImageIntensities.update_image_intensity(image_intensity, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_image_intensity/2 with invalid data returns error changeset" do
|
||||
image_intensity = image_intensity_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = ImageIntensities.update_image_intensity(image_intensity, @invalid_attrs)
|
||||
assert image_intensity == ImageIntensities.get_image_intensity!(image_intensity.id)
|
||||
end
|
||||
|
||||
test "delete_image_intensity/1 deletes the image_intensity" do
|
||||
image_intensity = image_intensity_fixture()
|
||||
assert {:ok, %ImageIntensity{}} = ImageIntensities.delete_image_intensity(image_intensity)
|
||||
assert_raise Ecto.NoResultsError, fn -> ImageIntensities.get_image_intensity!(image_intensity.id) end
|
||||
end
|
||||
|
||||
test "change_image_intensity/1 returns a image_intensity changeset" do
|
||||
image_intensity = image_intensity_fixture()
|
||||
assert %Ecto.Changeset{} = ImageIntensities.change_image_intensity(image_intensity)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.ImageVotesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.ImageVotes
|
||||
|
||||
describe "image_votes" do
|
||||
alias Philomena.ImageVotes.ImageVote
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def image_vote_fixture(attrs \\ %{}) do
|
||||
{:ok, image_vote} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> ImageVotes.create_image_vote()
|
||||
|
||||
image_vote
|
||||
end
|
||||
|
||||
test "list_image_votes/0 returns all image_votes" do
|
||||
image_vote = image_vote_fixture()
|
||||
assert ImageVotes.list_image_votes() == [image_vote]
|
||||
end
|
||||
|
||||
test "get_image_vote!/1 returns the image_vote with given id" do
|
||||
image_vote = image_vote_fixture()
|
||||
assert ImageVotes.get_image_vote!(image_vote.id) == image_vote
|
||||
end
|
||||
|
||||
test "create_image_vote/1 with valid data creates a image_vote" do
|
||||
assert {:ok, %ImageVote{} = image_vote} = ImageVotes.create_image_vote(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_image_vote/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = ImageVotes.create_image_vote(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_image_vote/2 with valid data updates the image_vote" do
|
||||
image_vote = image_vote_fixture()
|
||||
assert {:ok, %ImageVote{} = image_vote} = ImageVotes.update_image_vote(image_vote, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_image_vote/2 with invalid data returns error changeset" do
|
||||
image_vote = image_vote_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = ImageVotes.update_image_vote(image_vote, @invalid_attrs)
|
||||
assert image_vote == ImageVotes.get_image_vote!(image_vote.id)
|
||||
end
|
||||
|
||||
test "delete_image_vote/1 deletes the image_vote" do
|
||||
image_vote = image_vote_fixture()
|
||||
assert {:ok, %ImageVote{}} = ImageVotes.delete_image_vote(image_vote)
|
||||
assert_raise Ecto.NoResultsError, fn -> ImageVotes.get_image_vote!(image_vote.id) end
|
||||
end
|
||||
|
||||
test "change_image_vote/1 returns a image_vote changeset" do
|
||||
image_vote = image_vote_fixture()
|
||||
assert %Ecto.Changeset{} = ImageVotes.change_image_vote(image_vote)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,361 +0,0 @@
|
|||
defmodule Philomena.ImagesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Images
|
||||
|
||||
describe "images" do
|
||||
alias Philomena.Images.Image
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def image_fixture(attrs \\ %{}) do
|
||||
{:ok, image} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Images.create_image()
|
||||
|
||||
image
|
||||
end
|
||||
|
||||
test "list_images/0 returns all images" do
|
||||
image = image_fixture()
|
||||
assert Images.list_images() == [image]
|
||||
end
|
||||
|
||||
test "get_image!/1 returns the image with given id" do
|
||||
image = image_fixture()
|
||||
assert Images.get_image!(image.id) == image
|
||||
end
|
||||
|
||||
test "create_image/1 with valid data creates a image" do
|
||||
assert {:ok, %Image{} = image} = Images.create_image(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_image/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Images.create_image(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_image/2 with valid data updates the image" do
|
||||
image = image_fixture()
|
||||
assert {:ok, %Image{} = image} = Images.update_image(image, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_image/2 with invalid data returns error changeset" do
|
||||
image = image_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Images.update_image(image, @invalid_attrs)
|
||||
assert image == Images.get_image!(image.id)
|
||||
end
|
||||
|
||||
test "delete_image/1 deletes the image" do
|
||||
image = image_fixture()
|
||||
assert {:ok, %Image{}} = Images.delete_image(image)
|
||||
assert_raise Ecto.NoResultsError, fn -> Images.get_image!(image.id) end
|
||||
end
|
||||
|
||||
test "change_image/1 returns a image changeset" do
|
||||
image = image_fixture()
|
||||
assert %Ecto.Changeset{} = Images.change_image(image)
|
||||
end
|
||||
end
|
||||
|
||||
describe "image_features" do
|
||||
alias Philomena.Images.Features
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def features_fixture(attrs \\ %{}) do
|
||||
{:ok, features} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Images.create_features()
|
||||
|
||||
features
|
||||
end
|
||||
|
||||
test "list_image_features/0 returns all image_features" do
|
||||
features = features_fixture()
|
||||
assert Images.list_image_features() == [features]
|
||||
end
|
||||
|
||||
test "get_features!/1 returns the features with given id" do
|
||||
features = features_fixture()
|
||||
assert Images.get_features!(features.id) == features
|
||||
end
|
||||
|
||||
test "create_features/1 with valid data creates a features" do
|
||||
assert {:ok, %Features{} = features} = Images.create_features(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_features/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Images.create_features(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_features/2 with valid data updates the features" do
|
||||
features = features_fixture()
|
||||
assert {:ok, %Features{} = features} = Images.update_features(features, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_features/2 with invalid data returns error changeset" do
|
||||
features = features_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Images.update_features(features, @invalid_attrs)
|
||||
assert features == Images.get_features!(features.id)
|
||||
end
|
||||
|
||||
test "delete_features/1 deletes the features" do
|
||||
features = features_fixture()
|
||||
assert {:ok, %Features{}} = Images.delete_features(features)
|
||||
assert_raise Ecto.NoResultsError, fn -> Images.get_features!(features.id) end
|
||||
end
|
||||
|
||||
test "change_features/1 returns a features changeset" do
|
||||
features = features_fixture()
|
||||
assert %Ecto.Changeset{} = Images.change_features(features)
|
||||
end
|
||||
end
|
||||
|
||||
describe "image_intensities" do
|
||||
alias Philomena.Images.Intensities
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def intensities_fixture(attrs \\ %{}) do
|
||||
{:ok, intensities} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Images.create_intensities()
|
||||
|
||||
intensities
|
||||
end
|
||||
|
||||
test "list_image_intensities/0 returns all image_intensities" do
|
||||
intensities = intensities_fixture()
|
||||
assert Images.list_image_intensities() == [intensities]
|
||||
end
|
||||
|
||||
test "get_intensities!/1 returns the intensities with given id" do
|
||||
intensities = intensities_fixture()
|
||||
assert Images.get_intensities!(intensities.id) == intensities
|
||||
end
|
||||
|
||||
test "create_intensities/1 with valid data creates a intensities" do
|
||||
assert {:ok, %Intensities{} = intensities} = Images.create_intensities(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_intensities/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Images.create_intensities(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_intensities/2 with valid data updates the intensities" do
|
||||
intensities = intensities_fixture()
|
||||
|
||||
assert {:ok, %Intensities{} = intensities} =
|
||||
Images.update_intensities(intensities, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_intensities/2 with invalid data returns error changeset" do
|
||||
intensities = intensities_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Images.update_intensities(intensities, @invalid_attrs)
|
||||
assert intensities == Images.get_intensities!(intensities.id)
|
||||
end
|
||||
|
||||
test "delete_intensities/1 deletes the intensities" do
|
||||
intensities = intensities_fixture()
|
||||
assert {:ok, %Intensities{}} = Images.delete_intensities(intensities)
|
||||
assert_raise Ecto.NoResultsError, fn -> Images.get_intensities!(intensities.id) end
|
||||
end
|
||||
|
||||
test "change_intensities/1 returns a intensities changeset" do
|
||||
intensities = intensities_fixture()
|
||||
assert %Ecto.Changeset{} = Images.change_intensities(intensities)
|
||||
end
|
||||
end
|
||||
|
||||
describe "image_subscriptions" do
|
||||
alias Philomena.Images.Subscription
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def subscription_fixture(attrs \\ %{}) do
|
||||
{:ok, subscription} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Images.create_subscription()
|
||||
|
||||
subscription
|
||||
end
|
||||
|
||||
test "list_image_subscriptions/0 returns all image_subscriptions" do
|
||||
subscription = subscription_fixture()
|
||||
assert Images.list_image_subscriptions() == [subscription]
|
||||
end
|
||||
|
||||
test "get_subscription!/1 returns the subscription with given id" do
|
||||
subscription = subscription_fixture()
|
||||
assert Images.get_subscription!(subscription.id) == subscription
|
||||
end
|
||||
|
||||
test "create_subscription/1 with valid data creates a subscription" do
|
||||
assert {:ok, %Subscription{} = subscription} = Images.create_subscription(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_subscription/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Images.create_subscription(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with valid data updates the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
|
||||
assert {:ok, %Subscription{} = subscription} =
|
||||
Images.update_subscription(subscription, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with invalid data returns error changeset" do
|
||||
subscription = subscription_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Images.update_subscription(subscription, @invalid_attrs)
|
||||
|
||||
assert subscription == Images.get_subscription!(subscription.id)
|
||||
end
|
||||
|
||||
test "delete_subscription/1 deletes the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
assert {:ok, %Subscription{}} = Images.delete_subscription(subscription)
|
||||
assert_raise Ecto.NoResultsError, fn -> Images.get_subscription!(subscription.id) end
|
||||
end
|
||||
|
||||
test "change_subscription/1 returns a subscription changeset" do
|
||||
subscription = subscription_fixture()
|
||||
assert %Ecto.Changeset{} = Images.change_subscription(subscription)
|
||||
end
|
||||
end
|
||||
|
||||
describe "source_changes" do
|
||||
alias Philomena.Images.SourceChange
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def source_change_fixture(attrs \\ %{}) do
|
||||
{:ok, source_change} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Images.create_source_change()
|
||||
|
||||
source_change
|
||||
end
|
||||
|
||||
test "list_source_changes/0 returns all source_changes" do
|
||||
source_change = source_change_fixture()
|
||||
assert Images.list_source_changes() == [source_change]
|
||||
end
|
||||
|
||||
test "get_source_change!/1 returns the source_change with given id" do
|
||||
source_change = source_change_fixture()
|
||||
assert Images.get_source_change!(source_change.id) == source_change
|
||||
end
|
||||
|
||||
test "create_source_change/1 with valid data creates a source_change" do
|
||||
assert {:ok, %SourceChange{} = source_change} = Images.create_source_change(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_source_change/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Images.create_source_change(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_source_change/2 with valid data updates the source_change" do
|
||||
source_change = source_change_fixture()
|
||||
|
||||
assert {:ok, %SourceChange{} = source_change} =
|
||||
Images.update_source_change(source_change, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_source_change/2 with invalid data returns error changeset" do
|
||||
source_change = source_change_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Images.update_source_change(source_change, @invalid_attrs)
|
||||
|
||||
assert source_change == Images.get_source_change!(source_change.id)
|
||||
end
|
||||
|
||||
test "delete_source_change/1 deletes the source_change" do
|
||||
source_change = source_change_fixture()
|
||||
assert {:ok, %SourceChange{}} = Images.delete_source_change(source_change)
|
||||
assert_raise Ecto.NoResultsError, fn -> Images.get_source_change!(source_change.id) end
|
||||
end
|
||||
|
||||
test "change_source_change/1 returns a source_change changeset" do
|
||||
source_change = source_change_fixture()
|
||||
assert %Ecto.Changeset{} = Images.change_source_change(source_change)
|
||||
end
|
||||
end
|
||||
|
||||
describe "tag_changes" do
|
||||
alias Philomena.Images.TagChange
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def tag_change_fixture(attrs \\ %{}) do
|
||||
{:ok, tag_change} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Images.create_tag_change()
|
||||
|
||||
tag_change
|
||||
end
|
||||
|
||||
test "list_tag_changes/0 returns all tag_changes" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert Images.list_tag_changes() == [tag_change]
|
||||
end
|
||||
|
||||
test "get_tag_change!/1 returns the tag_change with given id" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert Images.get_tag_change!(tag_change.id) == tag_change
|
||||
end
|
||||
|
||||
test "create_tag_change/1 with valid data creates a tag_change" do
|
||||
assert {:ok, %TagChange{} = tag_change} = Images.create_tag_change(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_tag_change/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Images.create_tag_change(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_tag_change/2 with valid data updates the tag_change" do
|
||||
tag_change = tag_change_fixture()
|
||||
|
||||
assert {:ok, %TagChange{} = tag_change} =
|
||||
Images.update_tag_change(tag_change, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_tag_change/2 with invalid data returns error changeset" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Images.update_tag_change(tag_change, @invalid_attrs)
|
||||
assert tag_change == Images.get_tag_change!(tag_change.id)
|
||||
end
|
||||
|
||||
test "delete_tag_change/1 deletes the tag_change" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert {:ok, %TagChange{}} = Images.delete_tag_change(tag_change)
|
||||
assert_raise Ecto.NoResultsError, fn -> Images.get_tag_change!(tag_change.id) end
|
||||
end
|
||||
|
||||
test "change_tag_change/1 returns a tag_change changeset" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert %Ecto.Changeset{} = Images.change_tag_change(tag_change)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.ModNotesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.ModNotes
|
||||
|
||||
describe "mod_notes" do
|
||||
alias Philomena.ModNotes.ModNote
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def mod_note_fixture(attrs \\ %{}) do
|
||||
{:ok, mod_note} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> ModNotes.create_mod_note()
|
||||
|
||||
mod_note
|
||||
end
|
||||
|
||||
test "list_mod_notes/0 returns all mod_notes" do
|
||||
mod_note = mod_note_fixture()
|
||||
assert ModNotes.list_mod_notes() == [mod_note]
|
||||
end
|
||||
|
||||
test "get_mod_note!/1 returns the mod_note with given id" do
|
||||
mod_note = mod_note_fixture()
|
||||
assert ModNotes.get_mod_note!(mod_note.id) == mod_note
|
||||
end
|
||||
|
||||
test "create_mod_note/1 with valid data creates a mod_note" do
|
||||
assert {:ok, %ModNote{} = mod_note} = ModNotes.create_mod_note(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_mod_note/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = ModNotes.create_mod_note(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_mod_note/2 with valid data updates the mod_note" do
|
||||
mod_note = mod_note_fixture()
|
||||
assert {:ok, %ModNote{} = mod_note} = ModNotes.update_mod_note(mod_note, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_mod_note/2 with invalid data returns error changeset" do
|
||||
mod_note = mod_note_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = ModNotes.update_mod_note(mod_note, @invalid_attrs)
|
||||
assert mod_note == ModNotes.get_mod_note!(mod_note.id)
|
||||
end
|
||||
|
||||
test "delete_mod_note/1 deletes the mod_note" do
|
||||
mod_note = mod_note_fixture()
|
||||
assert {:ok, %ModNote{}} = ModNotes.delete_mod_note(mod_note)
|
||||
assert_raise Ecto.NoResultsError, fn -> ModNotes.get_mod_note!(mod_note.id) end
|
||||
end
|
||||
|
||||
test "change_mod_note/1 returns a mod_note changeset" do
|
||||
mod_note = mod_note_fixture()
|
||||
assert %Ecto.Changeset{} = ModNotes.change_mod_note(mod_note)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,137 +0,0 @@
|
|||
defmodule Philomena.NotificationsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Notifications
|
||||
|
||||
describe "notifications" do
|
||||
alias Philomena.Notifications.Notification
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def notification_fixture(attrs \\ %{}) do
|
||||
{:ok, notification} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Notifications.create_notification()
|
||||
|
||||
notification
|
||||
end
|
||||
|
||||
test "list_notifications/0 returns all notifications" do
|
||||
notification = notification_fixture()
|
||||
assert Notifications.list_notifications() == [notification]
|
||||
end
|
||||
|
||||
test "get_notification!/1 returns the notification with given id" do
|
||||
notification = notification_fixture()
|
||||
assert Notifications.get_notification!(notification.id) == notification
|
||||
end
|
||||
|
||||
test "create_notification/1 with valid data creates a notification" do
|
||||
assert {:ok, %Notification{} = notification} =
|
||||
Notifications.create_notification(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_notification/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Notifications.create_notification(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_notification/2 with valid data updates the notification" do
|
||||
notification = notification_fixture()
|
||||
|
||||
assert {:ok, %Notification{} = notification} =
|
||||
Notifications.update_notification(notification, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_notification/2 with invalid data returns error changeset" do
|
||||
notification = notification_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Notifications.update_notification(notification, @invalid_attrs)
|
||||
|
||||
assert notification == Notifications.get_notification!(notification.id)
|
||||
end
|
||||
|
||||
test "delete_notification/1 deletes the notification" do
|
||||
notification = notification_fixture()
|
||||
assert {:ok, %Notification{}} = Notifications.delete_notification(notification)
|
||||
assert_raise Ecto.NoResultsError, fn -> Notifications.get_notification!(notification.id) end
|
||||
end
|
||||
|
||||
test "change_notification/1 returns a notification changeset" do
|
||||
notification = notification_fixture()
|
||||
assert %Ecto.Changeset{} = Notifications.change_notification(notification)
|
||||
end
|
||||
end
|
||||
|
||||
describe "unread_notifications" do
|
||||
alias Philomena.Notifications.UnreadNotification
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def unread_notification_fixture(attrs \\ %{}) do
|
||||
{:ok, unread_notification} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Notifications.create_unread_notification()
|
||||
|
||||
unread_notification
|
||||
end
|
||||
|
||||
test "list_unread_notifications/0 returns all unread_notifications" do
|
||||
unread_notification = unread_notification_fixture()
|
||||
assert Notifications.list_unread_notifications() == [unread_notification]
|
||||
end
|
||||
|
||||
test "get_unread_notification!/1 returns the unread_notification with given id" do
|
||||
unread_notification = unread_notification_fixture()
|
||||
assert Notifications.get_unread_notification!(unread_notification.id) == unread_notification
|
||||
end
|
||||
|
||||
test "create_unread_notification/1 with valid data creates a unread_notification" do
|
||||
assert {:ok, %UnreadNotification{} = unread_notification} =
|
||||
Notifications.create_unread_notification(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_unread_notification/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Notifications.create_unread_notification(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_unread_notification/2 with valid data updates the unread_notification" do
|
||||
unread_notification = unread_notification_fixture()
|
||||
|
||||
assert {:ok, %UnreadNotification{} = unread_notification} =
|
||||
Notifications.update_unread_notification(unread_notification, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_unread_notification/2 with invalid data returns error changeset" do
|
||||
unread_notification = unread_notification_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Notifications.update_unread_notification(unread_notification, @invalid_attrs)
|
||||
|
||||
assert unread_notification == Notifications.get_unread_notification!(unread_notification.id)
|
||||
end
|
||||
|
||||
test "delete_unread_notification/1 deletes the unread_notification" do
|
||||
unread_notification = unread_notification_fixture()
|
||||
|
||||
assert {:ok, %UnreadNotification{}} =
|
||||
Notifications.delete_unread_notification(unread_notification)
|
||||
|
||||
assert_raise Ecto.NoResultsError, fn ->
|
||||
Notifications.get_unread_notification!(unread_notification.id)
|
||||
end
|
||||
end
|
||||
|
||||
test "change_unread_notification/1 returns a unread_notification changeset" do
|
||||
unread_notification = unread_notification_fixture()
|
||||
assert %Ecto.Changeset{} = Notifications.change_unread_notification(unread_notification)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
defmodule Philomena.PollOptionsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.PollOptions
|
||||
|
||||
describe "poll_options" do
|
||||
alias Philomena.PollOptions.PollOption
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def poll_option_fixture(attrs \\ %{}) do
|
||||
{:ok, poll_option} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> PollOptions.create_poll_option()
|
||||
|
||||
poll_option
|
||||
end
|
||||
|
||||
test "list_poll_options/0 returns all poll_options" do
|
||||
poll_option = poll_option_fixture()
|
||||
assert PollOptions.list_poll_options() == [poll_option]
|
||||
end
|
||||
|
||||
test "get_poll_option!/1 returns the poll_option with given id" do
|
||||
poll_option = poll_option_fixture()
|
||||
assert PollOptions.get_poll_option!(poll_option.id) == poll_option
|
||||
end
|
||||
|
||||
test "create_poll_option/1 with valid data creates a poll_option" do
|
||||
assert {:ok, %PollOption{} = poll_option} = PollOptions.create_poll_option(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_poll_option/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = PollOptions.create_poll_option(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_poll_option/2 with valid data updates the poll_option" do
|
||||
poll_option = poll_option_fixture()
|
||||
|
||||
assert {:ok, %PollOption{} = poll_option} =
|
||||
PollOptions.update_poll_option(poll_option, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_poll_option/2 with invalid data returns error changeset" do
|
||||
poll_option = poll_option_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
PollOptions.update_poll_option(poll_option, @invalid_attrs)
|
||||
|
||||
assert poll_option == PollOptions.get_poll_option!(poll_option.id)
|
||||
end
|
||||
|
||||
test "delete_poll_option/1 deletes the poll_option" do
|
||||
poll_option = poll_option_fixture()
|
||||
assert {:ok, %PollOption{}} = PollOptions.delete_poll_option(poll_option)
|
||||
assert_raise Ecto.NoResultsError, fn -> PollOptions.get_poll_option!(poll_option.id) end
|
||||
end
|
||||
|
||||
test "change_poll_option/1 returns a poll_option changeset" do
|
||||
poll_option = poll_option_fixture()
|
||||
assert %Ecto.Changeset{} = PollOptions.change_poll_option(poll_option)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.PollVotesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.PollVotes
|
||||
|
||||
describe "poll_votes" do
|
||||
alias Philomena.PollVotes.PollVote
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def poll_vote_fixture(attrs \\ %{}) do
|
||||
{:ok, poll_vote} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> PollVotes.create_poll_vote()
|
||||
|
||||
poll_vote
|
||||
end
|
||||
|
||||
test "list_poll_votes/0 returns all poll_votes" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert PollVotes.list_poll_votes() == [poll_vote]
|
||||
end
|
||||
|
||||
test "get_poll_vote!/1 returns the poll_vote with given id" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert PollVotes.get_poll_vote!(poll_vote.id) == poll_vote
|
||||
end
|
||||
|
||||
test "create_poll_vote/1 with valid data creates a poll_vote" do
|
||||
assert {:ok, %PollVote{} = poll_vote} = PollVotes.create_poll_vote(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_poll_vote/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = PollVotes.create_poll_vote(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_poll_vote/2 with valid data updates the poll_vote" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert {:ok, %PollVote{} = poll_vote} = PollVotes.update_poll_vote(poll_vote, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_poll_vote/2 with invalid data returns error changeset" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = PollVotes.update_poll_vote(poll_vote, @invalid_attrs)
|
||||
assert poll_vote == PollVotes.get_poll_vote!(poll_vote.id)
|
||||
end
|
||||
|
||||
test "delete_poll_vote/1 deletes the poll_vote" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert {:ok, %PollVote{}} = PollVotes.delete_poll_vote(poll_vote)
|
||||
assert_raise Ecto.NoResultsError, fn -> PollVotes.get_poll_vote!(poll_vote.id) end
|
||||
end
|
||||
|
||||
test "change_poll_vote/1 returns a poll_vote changeset" do
|
||||
poll_vote = poll_vote_fixture()
|
||||
assert %Ecto.Changeset{} = PollVotes.change_poll_vote(poll_vote)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.PollsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Polls
|
||||
|
||||
describe "polls" do
|
||||
alias Philomena.Polls.Poll
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def poll_fixture(attrs \\ %{}) do
|
||||
{:ok, poll} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Polls.create_poll()
|
||||
|
||||
poll
|
||||
end
|
||||
|
||||
test "list_polls/0 returns all polls" do
|
||||
poll = poll_fixture()
|
||||
assert Polls.list_polls() == [poll]
|
||||
end
|
||||
|
||||
test "get_poll!/1 returns the poll with given id" do
|
||||
poll = poll_fixture()
|
||||
assert Polls.get_poll!(poll.id) == poll
|
||||
end
|
||||
|
||||
test "create_poll/1 with valid data creates a poll" do
|
||||
assert {:ok, %Poll{} = poll} = Polls.create_poll(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_poll/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Polls.create_poll(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_poll/2 with valid data updates the poll" do
|
||||
poll = poll_fixture()
|
||||
assert {:ok, %Poll{} = poll} = Polls.update_poll(poll, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_poll/2 with invalid data returns error changeset" do
|
||||
poll = poll_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Polls.update_poll(poll, @invalid_attrs)
|
||||
assert poll == Polls.get_poll!(poll.id)
|
||||
end
|
||||
|
||||
test "delete_poll/1 deletes the poll" do
|
||||
poll = poll_fixture()
|
||||
assert {:ok, %Poll{}} = Polls.delete_poll(poll)
|
||||
assert_raise Ecto.NoResultsError, fn -> Polls.get_poll!(poll.id) end
|
||||
end
|
||||
|
||||
test "change_poll/1 returns a poll changeset" do
|
||||
poll = poll_fixture()
|
||||
assert %Ecto.Changeset{} = Polls.change_poll(poll)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.PostsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Posts
|
||||
|
||||
describe "posts" do
|
||||
alias Philomena.Posts.Post
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def post_fixture(attrs \\ %{}) do
|
||||
{:ok, post} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Posts.create_post()
|
||||
|
||||
post
|
||||
end
|
||||
|
||||
test "list_posts/0 returns all posts" do
|
||||
post = post_fixture()
|
||||
assert Posts.list_posts() == [post]
|
||||
end
|
||||
|
||||
test "get_post!/1 returns the post with given id" do
|
||||
post = post_fixture()
|
||||
assert Posts.get_post!(post.id) == post
|
||||
end
|
||||
|
||||
test "create_post/1 with valid data creates a post" do
|
||||
assert {:ok, %Post{} = post} = Posts.create_post(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_post/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Posts.create_post(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_post/2 with valid data updates the post" do
|
||||
post = post_fixture()
|
||||
assert {:ok, %Post{} = post} = Posts.update_post(post, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_post/2 with invalid data returns error changeset" do
|
||||
post = post_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Posts.update_post(post, @invalid_attrs)
|
||||
assert post == Posts.get_post!(post.id)
|
||||
end
|
||||
|
||||
test "delete_post/1 deletes the post" do
|
||||
post = post_fixture()
|
||||
assert {:ok, %Post{}} = Posts.delete_post(post)
|
||||
assert_raise Ecto.NoResultsError, fn -> Posts.get_post!(post.id) end
|
||||
end
|
||||
|
||||
test "change_post/1 returns a post changeset" do
|
||||
post = post_fixture()
|
||||
assert %Ecto.Changeset{} = Posts.change_post(post)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.ReportsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Reports
|
||||
|
||||
describe "reports" do
|
||||
alias Philomena.Reports.Report
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def report_fixture(attrs \\ %{}) do
|
||||
{:ok, report} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Reports.create_report()
|
||||
|
||||
report
|
||||
end
|
||||
|
||||
test "list_reports/0 returns all reports" do
|
||||
report = report_fixture()
|
||||
assert Reports.list_reports() == [report]
|
||||
end
|
||||
|
||||
test "get_report!/1 returns the report with given id" do
|
||||
report = report_fixture()
|
||||
assert Reports.get_report!(report.id) == report
|
||||
end
|
||||
|
||||
test "create_report/1 with valid data creates a report" do
|
||||
assert {:ok, %Report{} = report} = Reports.create_report(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_report/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Reports.create_report(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_report/2 with valid data updates the report" do
|
||||
report = report_fixture()
|
||||
assert {:ok, %Report{} = report} = Reports.update_report(report, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_report/2 with invalid data returns error changeset" do
|
||||
report = report_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Reports.update_report(report, @invalid_attrs)
|
||||
assert report == Reports.get_report!(report.id)
|
||||
end
|
||||
|
||||
test "delete_report/1 deletes the report" do
|
||||
report = report_fixture()
|
||||
assert {:ok, %Report{}} = Reports.delete_report(report)
|
||||
assert_raise Ecto.NoResultsError, fn -> Reports.get_report!(report.id) end
|
||||
end
|
||||
|
||||
test "change_report/1 returns a report changeset" do
|
||||
report = report_fixture()
|
||||
assert %Ecto.Changeset{} = Reports.change_report(report)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.RolesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Roles
|
||||
|
||||
describe "roles" do
|
||||
alias Philomena.Roles.Role
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def role_fixture(attrs \\ %{}) do
|
||||
{:ok, role} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Roles.create_role()
|
||||
|
||||
role
|
||||
end
|
||||
|
||||
test "list_roles/0 returns all roles" do
|
||||
role = role_fixture()
|
||||
assert Roles.list_roles() == [role]
|
||||
end
|
||||
|
||||
test "get_role!/1 returns the role with given id" do
|
||||
role = role_fixture()
|
||||
assert Roles.get_role!(role.id) == role
|
||||
end
|
||||
|
||||
test "create_role/1 with valid data creates a role" do
|
||||
assert {:ok, %Role{} = role} = Roles.create_role(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_role/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Roles.create_role(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_role/2 with valid data updates the role" do
|
||||
role = role_fixture()
|
||||
assert {:ok, %Role{} = role} = Roles.update_role(role, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_role/2 with invalid data returns error changeset" do
|
||||
role = role_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Roles.update_role(role, @invalid_attrs)
|
||||
assert role == Roles.get_role!(role.id)
|
||||
end
|
||||
|
||||
test "delete_role/1 deletes the role" do
|
||||
role = role_fixture()
|
||||
assert {:ok, %Role{}} = Roles.delete_role(role)
|
||||
assert_raise Ecto.NoResultsError, fn -> Roles.get_role!(role.id) end
|
||||
end
|
||||
|
||||
test "change_role/1 returns a role changeset" do
|
||||
role = role_fixture()
|
||||
assert %Ecto.Changeset{} = Roles.change_role(role)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
defmodule Philomena.SiteNoticesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.SiteNotices
|
||||
|
||||
describe "site_notices" do
|
||||
alias Philomena.SiteNotices.SiteNotice
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def site_notice_fixture(attrs \\ %{}) do
|
||||
{:ok, site_notice} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> SiteNotices.create_site_notice()
|
||||
|
||||
site_notice
|
||||
end
|
||||
|
||||
test "list_site_notices/0 returns all site_notices" do
|
||||
site_notice = site_notice_fixture()
|
||||
assert SiteNotices.list_site_notices() == [site_notice]
|
||||
end
|
||||
|
||||
test "get_site_notice!/1 returns the site_notice with given id" do
|
||||
site_notice = site_notice_fixture()
|
||||
assert SiteNotices.get_site_notice!(site_notice.id) == site_notice
|
||||
end
|
||||
|
||||
test "create_site_notice/1 with valid data creates a site_notice" do
|
||||
assert {:ok, %SiteNotice{} = site_notice} = SiteNotices.create_site_notice(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_site_notice/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = SiteNotices.create_site_notice(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_site_notice/2 with valid data updates the site_notice" do
|
||||
site_notice = site_notice_fixture()
|
||||
|
||||
assert {:ok, %SiteNotice{} = site_notice} =
|
||||
SiteNotices.update_site_notice(site_notice, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_site_notice/2 with invalid data returns error changeset" do
|
||||
site_notice = site_notice_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
SiteNotices.update_site_notice(site_notice, @invalid_attrs)
|
||||
|
||||
assert site_notice == SiteNotices.get_site_notice!(site_notice.id)
|
||||
end
|
||||
|
||||
test "delete_site_notice/1 deletes the site_notice" do
|
||||
site_notice = site_notice_fixture()
|
||||
assert {:ok, %SiteNotice{}} = SiteNotices.delete_site_notice(site_notice)
|
||||
assert_raise Ecto.NoResultsError, fn -> SiteNotices.get_site_notice!(site_notice.id) end
|
||||
end
|
||||
|
||||
test "change_site_notice/1 returns a site_notice changeset" do
|
||||
site_notice = site_notice_fixture()
|
||||
assert %Ecto.Changeset{} = SiteNotices.change_site_notice(site_notice)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.SourceChangesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.SourceChanges
|
||||
|
||||
describe "source_changes" do
|
||||
alias Philomena.SourceChanges.SourceChange
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def source_change_fixture(attrs \\ %{}) do
|
||||
{:ok, source_change} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> SourceChanges.create_source_change()
|
||||
|
||||
source_change
|
||||
end
|
||||
|
||||
test "list_source_changes/0 returns all source_changes" do
|
||||
source_change = source_change_fixture()
|
||||
assert SourceChanges.list_source_changes() == [source_change]
|
||||
end
|
||||
|
||||
test "get_source_change!/1 returns the source_change with given id" do
|
||||
source_change = source_change_fixture()
|
||||
assert SourceChanges.get_source_change!(source_change.id) == source_change
|
||||
end
|
||||
|
||||
test "create_source_change/1 with valid data creates a source_change" do
|
||||
assert {:ok, %SourceChange{} = source_change} = SourceChanges.create_source_change(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_source_change/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = SourceChanges.create_source_change(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_source_change/2 with valid data updates the source_change" do
|
||||
source_change = source_change_fixture()
|
||||
assert {:ok, %SourceChange{} = source_change} = SourceChanges.update_source_change(source_change, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_source_change/2 with invalid data returns error changeset" do
|
||||
source_change = source_change_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = SourceChanges.update_source_change(source_change, @invalid_attrs)
|
||||
assert source_change == SourceChanges.get_source_change!(source_change.id)
|
||||
end
|
||||
|
||||
test "delete_source_change/1 deletes the source_change" do
|
||||
source_change = source_change_fixture()
|
||||
assert {:ok, %SourceChange{}} = SourceChanges.delete_source_change(source_change)
|
||||
assert_raise Ecto.NoResultsError, fn -> SourceChanges.get_source_change!(source_change.id) end
|
||||
end
|
||||
|
||||
test "change_source_change/1 returns a source_change changeset" do
|
||||
source_change = source_change_fixture()
|
||||
assert %Ecto.Changeset{} = SourceChanges.change_source_change(source_change)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.StaticPagesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.StaticPages
|
||||
|
||||
describe "static_pages" do
|
||||
alias Philomena.StaticPages.StaticPage
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def static_page_fixture(attrs \\ %{}) do
|
||||
{:ok, static_page} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> StaticPages.create_static_page()
|
||||
|
||||
static_page
|
||||
end
|
||||
|
||||
test "list_static_pages/0 returns all static_pages" do
|
||||
static_page = static_page_fixture()
|
||||
assert StaticPages.list_static_pages() == [static_page]
|
||||
end
|
||||
|
||||
test "get_static_page!/1 returns the static_page with given id" do
|
||||
static_page = static_page_fixture()
|
||||
assert StaticPages.get_static_page!(static_page.id) == static_page
|
||||
end
|
||||
|
||||
test "create_static_page/1 with valid data creates a static_page" do
|
||||
assert {:ok, %StaticPage{} = static_page} = StaticPages.create_static_page(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_static_page/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = StaticPages.create_static_page(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_static_page/2 with valid data updates the static_page" do
|
||||
static_page = static_page_fixture()
|
||||
assert {:ok, %StaticPage{} = static_page} = StaticPages.update_static_page(static_page, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_static_page/2 with invalid data returns error changeset" do
|
||||
static_page = static_page_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = StaticPages.update_static_page(static_page, @invalid_attrs)
|
||||
assert static_page == StaticPages.get_static_page!(static_page.id)
|
||||
end
|
||||
|
||||
test "delete_static_page/1 deletes the static_page" do
|
||||
static_page = static_page_fixture()
|
||||
assert {:ok, %StaticPage{}} = StaticPages.delete_static_page(static_page)
|
||||
assert_raise Ecto.NoResultsError, fn -> StaticPages.get_static_page!(static_page.id) end
|
||||
end
|
||||
|
||||
test "change_static_page/1 returns a static_page changeset" do
|
||||
static_page = static_page_fixture()
|
||||
assert %Ecto.Changeset{} = StaticPages.change_static_page(static_page)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.TagChangesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.TagChanges
|
||||
|
||||
describe "tag_changes" do
|
||||
alias Philomena.TagChanges.TagChange
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def tag_change_fixture(attrs \\ %{}) do
|
||||
{:ok, tag_change} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> TagChanges.create_tag_change()
|
||||
|
||||
tag_change
|
||||
end
|
||||
|
||||
test "list_tag_changes/0 returns all tag_changes" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert TagChanges.list_tag_changes() == [tag_change]
|
||||
end
|
||||
|
||||
test "get_tag_change!/1 returns the tag_change with given id" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert TagChanges.get_tag_change!(tag_change.id) == tag_change
|
||||
end
|
||||
|
||||
test "create_tag_change/1 with valid data creates a tag_change" do
|
||||
assert {:ok, %TagChange{} = tag_change} = TagChanges.create_tag_change(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_tag_change/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = TagChanges.create_tag_change(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_tag_change/2 with valid data updates the tag_change" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert {:ok, %TagChange{} = tag_change} = TagChanges.update_tag_change(tag_change, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_tag_change/2 with invalid data returns error changeset" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = TagChanges.update_tag_change(tag_change, @invalid_attrs)
|
||||
assert tag_change == TagChanges.get_tag_change!(tag_change.id)
|
||||
end
|
||||
|
||||
test "delete_tag_change/1 deletes the tag_change" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert {:ok, %TagChange{}} = TagChanges.delete_tag_change(tag_change)
|
||||
assert_raise Ecto.NoResultsError, fn -> TagChanges.get_tag_change!(tag_change.id) end
|
||||
end
|
||||
|
||||
test "change_tag_change/1 returns a tag_change changeset" do
|
||||
tag_change = tag_change_fixture()
|
||||
assert %Ecto.Changeset{} = TagChanges.change_tag_change(tag_change)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,121 +0,0 @@
|
|||
defmodule Philomena.TagsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Tags
|
||||
|
||||
describe "tags" do
|
||||
alias Philomena.Tags.Tag
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def tag_fixture(attrs \\ %{}) do
|
||||
{:ok, tag} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Tags.create_tag()
|
||||
|
||||
tag
|
||||
end
|
||||
|
||||
test "list_tags/0 returns all tags" do
|
||||
tag = tag_fixture()
|
||||
assert Tags.list_tags() == [tag]
|
||||
end
|
||||
|
||||
test "get_tag!/1 returns the tag with given id" do
|
||||
tag = tag_fixture()
|
||||
assert Tags.get_tag!(tag.id) == tag
|
||||
end
|
||||
|
||||
test "create_tag/1 with valid data creates a tag" do
|
||||
assert {:ok, %Tag{} = tag} = Tags.create_tag(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_tag/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Tags.create_tag(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_tag/2 with valid data updates the tag" do
|
||||
tag = tag_fixture()
|
||||
assert {:ok, %Tag{} = tag} = Tags.update_tag(tag, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_tag/2 with invalid data returns error changeset" do
|
||||
tag = tag_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Tags.update_tag(tag, @invalid_attrs)
|
||||
assert tag == Tags.get_tag!(tag.id)
|
||||
end
|
||||
|
||||
test "delete_tag/1 deletes the tag" do
|
||||
tag = tag_fixture()
|
||||
assert {:ok, %Tag{}} = Tags.delete_tag(tag)
|
||||
assert_raise Ecto.NoResultsError, fn -> Tags.get_tag!(tag.id) end
|
||||
end
|
||||
|
||||
test "change_tag/1 returns a tag changeset" do
|
||||
tag = tag_fixture()
|
||||
assert %Ecto.Changeset{} = Tags.change_tag(tag)
|
||||
end
|
||||
end
|
||||
|
||||
describe "tags_implied_tags" do
|
||||
alias Philomena.Tags.Implication
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def implication_fixture(attrs \\ %{}) do
|
||||
{:ok, implication} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Tags.create_implication()
|
||||
|
||||
implication
|
||||
end
|
||||
|
||||
test "list_tags_implied_tags/0 returns all tags_implied_tags" do
|
||||
implication = implication_fixture()
|
||||
assert Tags.list_tags_implied_tags() == [implication]
|
||||
end
|
||||
|
||||
test "get_implication!/1 returns the implication with given id" do
|
||||
implication = implication_fixture()
|
||||
assert Tags.get_implication!(implication.id) == implication
|
||||
end
|
||||
|
||||
test "create_implication/1 with valid data creates a implication" do
|
||||
assert {:ok, %Implication{} = implication} = Tags.create_implication(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_implication/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Tags.create_implication(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_implication/2 with valid data updates the implication" do
|
||||
implication = implication_fixture()
|
||||
|
||||
assert {:ok, %Implication{} = implication} =
|
||||
Tags.update_implication(implication, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_implication/2 with invalid data returns error changeset" do
|
||||
implication = implication_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Tags.update_implication(implication, @invalid_attrs)
|
||||
assert implication == Tags.get_implication!(implication.id)
|
||||
end
|
||||
|
||||
test "delete_implication/1 deletes the implication" do
|
||||
implication = implication_fixture()
|
||||
assert {:ok, %Implication{}} = Tags.delete_implication(implication)
|
||||
assert_raise Ecto.NoResultsError, fn -> Tags.get_implication!(implication.id) end
|
||||
end
|
||||
|
||||
test "change_implication/1 returns a implication changeset" do
|
||||
implication = implication_fixture()
|
||||
assert %Ecto.Changeset{} = Tags.change_implication(implication)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
defmodule Philomena.TopicsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Topics
|
||||
|
||||
describe "topics" do
|
||||
alias Philomena.Topics.Topic
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def topic_fixture(attrs \\ %{}) do
|
||||
{:ok, topic} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Topics.create_topic()
|
||||
|
||||
topic
|
||||
end
|
||||
|
||||
test "list_topics/0 returns all topics" do
|
||||
topic = topic_fixture()
|
||||
assert Topics.list_topics() == [topic]
|
||||
end
|
||||
|
||||
test "get_topic!/1 returns the topic with given id" do
|
||||
topic = topic_fixture()
|
||||
assert Topics.get_topic!(topic.id) == topic
|
||||
end
|
||||
|
||||
test "create_topic/1 with valid data creates a topic" do
|
||||
assert {:ok, %Topic{} = topic} = Topics.create_topic(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_topic/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Topics.create_topic(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_topic/2 with valid data updates the topic" do
|
||||
topic = topic_fixture()
|
||||
assert {:ok, %Topic{} = topic} = Topics.update_topic(topic, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_topic/2 with invalid data returns error changeset" do
|
||||
topic = topic_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Topics.update_topic(topic, @invalid_attrs)
|
||||
assert topic == Topics.get_topic!(topic.id)
|
||||
end
|
||||
|
||||
test "delete_topic/1 deletes the topic" do
|
||||
topic = topic_fixture()
|
||||
assert {:ok, %Topic{}} = Topics.delete_topic(topic)
|
||||
assert_raise Ecto.NoResultsError, fn -> Topics.get_topic!(topic.id) end
|
||||
end
|
||||
|
||||
test "change_topic/1 returns a topic changeset" do
|
||||
topic = topic_fixture()
|
||||
assert %Ecto.Changeset{} = Topics.change_topic(topic)
|
||||
end
|
||||
end
|
||||
|
||||
describe "topic_subscriptions" do
|
||||
alias Philomena.Topics.Subscription
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def subscription_fixture(attrs \\ %{}) do
|
||||
{:ok, subscription} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Topics.create_subscription()
|
||||
|
||||
subscription
|
||||
end
|
||||
|
||||
test "list_topic_subscriptions/0 returns all topic_subscriptions" do
|
||||
subscription = subscription_fixture()
|
||||
assert Topics.list_topic_subscriptions() == [subscription]
|
||||
end
|
||||
|
||||
test "get_subscription!/1 returns the subscription with given id" do
|
||||
subscription = subscription_fixture()
|
||||
assert Topics.get_subscription!(subscription.id) == subscription
|
||||
end
|
||||
|
||||
test "create_subscription/1 with valid data creates a subscription" do
|
||||
assert {:ok, %Subscription{} = subscription} = Topics.create_subscription(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_subscription/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Topics.create_subscription(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with valid data updates the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
|
||||
assert {:ok, %Subscription{} = subscription} =
|
||||
Topics.update_subscription(subscription, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_subscription/2 with invalid data returns error changeset" do
|
||||
subscription = subscription_fixture()
|
||||
|
||||
assert {:error, %Ecto.Changeset{}} =
|
||||
Topics.update_subscription(subscription, @invalid_attrs)
|
||||
|
||||
assert subscription == Topics.get_subscription!(subscription.id)
|
||||
end
|
||||
|
||||
test "delete_subscription/1 deletes the subscription" do
|
||||
subscription = subscription_fixture()
|
||||
assert {:ok, %Subscription{}} = Topics.delete_subscription(subscription)
|
||||
assert_raise Ecto.NoResultsError, fn -> Topics.get_subscription!(subscription.id) end
|
||||
end
|
||||
|
||||
test "change_subscription/1 returns a subscription changeset" do
|
||||
subscription = subscription_fixture()
|
||||
assert %Ecto.Changeset{} = Topics.change_subscription(subscription)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.UserFingerprintsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.UserFingerprints
|
||||
|
||||
describe "user_fingerprints" do
|
||||
alias Philomena.UserFingerprints.UserFingerprint
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def user_fingerprint_fixture(attrs \\ %{}) do
|
||||
{:ok, user_fingerprint} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> UserFingerprints.create_user_fingerprint()
|
||||
|
||||
user_fingerprint
|
||||
end
|
||||
|
||||
test "list_user_fingerprints/0 returns all user_fingerprints" do
|
||||
user_fingerprint = user_fingerprint_fixture()
|
||||
assert UserFingerprints.list_user_fingerprints() == [user_fingerprint]
|
||||
end
|
||||
|
||||
test "get_user_fingerprint!/1 returns the user_fingerprint with given id" do
|
||||
user_fingerprint = user_fingerprint_fixture()
|
||||
assert UserFingerprints.get_user_fingerprint!(user_fingerprint.id) == user_fingerprint
|
||||
end
|
||||
|
||||
test "create_user_fingerprint/1 with valid data creates a user_fingerprint" do
|
||||
assert {:ok, %UserFingerprint{} = user_fingerprint} = UserFingerprints.create_user_fingerprint(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_user_fingerprint/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = UserFingerprints.create_user_fingerprint(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_user_fingerprint/2 with valid data updates the user_fingerprint" do
|
||||
user_fingerprint = user_fingerprint_fixture()
|
||||
assert {:ok, %UserFingerprint{} = user_fingerprint} = UserFingerprints.update_user_fingerprint(user_fingerprint, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_user_fingerprint/2 with invalid data returns error changeset" do
|
||||
user_fingerprint = user_fingerprint_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = UserFingerprints.update_user_fingerprint(user_fingerprint, @invalid_attrs)
|
||||
assert user_fingerprint == UserFingerprints.get_user_fingerprint!(user_fingerprint.id)
|
||||
end
|
||||
|
||||
test "delete_user_fingerprint/1 deletes the user_fingerprint" do
|
||||
user_fingerprint = user_fingerprint_fixture()
|
||||
assert {:ok, %UserFingerprint{}} = UserFingerprints.delete_user_fingerprint(user_fingerprint)
|
||||
assert_raise Ecto.NoResultsError, fn -> UserFingerprints.get_user_fingerprint!(user_fingerprint.id) end
|
||||
end
|
||||
|
||||
test "change_user_fingerprint/1 returns a user_fingerprint changeset" do
|
||||
user_fingerprint = user_fingerprint_fixture()
|
||||
assert %Ecto.Changeset{} = UserFingerprints.change_user_fingerprint(user_fingerprint)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.UserIpsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.UserIps
|
||||
|
||||
describe "user_ips" do
|
||||
alias Philomena.UserIps.UserIp
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def user_ip_fixture(attrs \\ %{}) do
|
||||
{:ok, user_ip} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> UserIps.create_user_ip()
|
||||
|
||||
user_ip
|
||||
end
|
||||
|
||||
test "list_user_ips/0 returns all user_ips" do
|
||||
user_ip = user_ip_fixture()
|
||||
assert UserIps.list_user_ips() == [user_ip]
|
||||
end
|
||||
|
||||
test "get_user_ip!/1 returns the user_ip with given id" do
|
||||
user_ip = user_ip_fixture()
|
||||
assert UserIps.get_user_ip!(user_ip.id) == user_ip
|
||||
end
|
||||
|
||||
test "create_user_ip/1 with valid data creates a user_ip" do
|
||||
assert {:ok, %UserIp{} = user_ip} = UserIps.create_user_ip(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_user_ip/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = UserIps.create_user_ip(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_user_ip/2 with valid data updates the user_ip" do
|
||||
user_ip = user_ip_fixture()
|
||||
assert {:ok, %UserIp{} = user_ip} = UserIps.update_user_ip(user_ip, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_user_ip/2 with invalid data returns error changeset" do
|
||||
user_ip = user_ip_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = UserIps.update_user_ip(user_ip, @invalid_attrs)
|
||||
assert user_ip == UserIps.get_user_ip!(user_ip.id)
|
||||
end
|
||||
|
||||
test "delete_user_ip/1 deletes the user_ip" do
|
||||
user_ip = user_ip_fixture()
|
||||
assert {:ok, %UserIp{}} = UserIps.delete_user_ip(user_ip)
|
||||
assert_raise Ecto.NoResultsError, fn -> UserIps.get_user_ip!(user_ip.id) end
|
||||
end
|
||||
|
||||
test "change_user_ip/1 returns a user_ip changeset" do
|
||||
user_ip = user_ip_fixture()
|
||||
assert %Ecto.Changeset{} = UserIps.change_user_ip(user_ip)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.UserLinksTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.UserLinks
|
||||
|
||||
describe "user_links" do
|
||||
alias Philomena.UserLinks.UserLink
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def user_link_fixture(attrs \\ %{}) do
|
||||
{:ok, user_link} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> UserLinks.create_user_link()
|
||||
|
||||
user_link
|
||||
end
|
||||
|
||||
test "list_user_links/0 returns all user_links" do
|
||||
user_link = user_link_fixture()
|
||||
assert UserLinks.list_user_links() == [user_link]
|
||||
end
|
||||
|
||||
test "get_user_link!/1 returns the user_link with given id" do
|
||||
user_link = user_link_fixture()
|
||||
assert UserLinks.get_user_link!(user_link.id) == user_link
|
||||
end
|
||||
|
||||
test "create_user_link/1 with valid data creates a user_link" do
|
||||
assert {:ok, %UserLink{} = user_link} = UserLinks.create_user_link(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_user_link/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = UserLinks.create_user_link(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_user_link/2 with valid data updates the user_link" do
|
||||
user_link = user_link_fixture()
|
||||
assert {:ok, %UserLink{} = user_link} = UserLinks.update_user_link(user_link, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_user_link/2 with invalid data returns error changeset" do
|
||||
user_link = user_link_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = UserLinks.update_user_link(user_link, @invalid_attrs)
|
||||
assert user_link == UserLinks.get_user_link!(user_link.id)
|
||||
end
|
||||
|
||||
test "delete_user_link/1 deletes the user_link" do
|
||||
user_link = user_link_fixture()
|
||||
assert {:ok, %UserLink{}} = UserLinks.delete_user_link(user_link)
|
||||
assert_raise Ecto.NoResultsError, fn -> UserLinks.get_user_link!(user_link.id) end
|
||||
end
|
||||
|
||||
test "change_user_link/1 returns a user_link changeset" do
|
||||
user_link = user_link_fixture()
|
||||
assert %Ecto.Changeset{} = UserLinks.change_user_link(user_link)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.UserNameChangesTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.UserNameChanges
|
||||
|
||||
describe "user_name_changes" do
|
||||
alias Philomena.UserNameChanges.UserNameChange
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def user_name_change_fixture(attrs \\ %{}) do
|
||||
{:ok, user_name_change} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> UserNameChanges.create_user_name_change()
|
||||
|
||||
user_name_change
|
||||
end
|
||||
|
||||
test "list_user_name_changes/0 returns all user_name_changes" do
|
||||
user_name_change = user_name_change_fixture()
|
||||
assert UserNameChanges.list_user_name_changes() == [user_name_change]
|
||||
end
|
||||
|
||||
test "get_user_name_change!/1 returns the user_name_change with given id" do
|
||||
user_name_change = user_name_change_fixture()
|
||||
assert UserNameChanges.get_user_name_change!(user_name_change.id) == user_name_change
|
||||
end
|
||||
|
||||
test "create_user_name_change/1 with valid data creates a user_name_change" do
|
||||
assert {:ok, %UserNameChange{} = user_name_change} = UserNameChanges.create_user_name_change(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_user_name_change/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = UserNameChanges.create_user_name_change(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_user_name_change/2 with valid data updates the user_name_change" do
|
||||
user_name_change = user_name_change_fixture()
|
||||
assert {:ok, %UserNameChange{} = user_name_change} = UserNameChanges.update_user_name_change(user_name_change, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_user_name_change/2 with invalid data returns error changeset" do
|
||||
user_name_change = user_name_change_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = UserNameChanges.update_user_name_change(user_name_change, @invalid_attrs)
|
||||
assert user_name_change == UserNameChanges.get_user_name_change!(user_name_change.id)
|
||||
end
|
||||
|
||||
test "delete_user_name_change/1 deletes the user_name_change" do
|
||||
user_name_change = user_name_change_fixture()
|
||||
assert {:ok, %UserNameChange{}} = UserNameChanges.delete_user_name_change(user_name_change)
|
||||
assert_raise Ecto.NoResultsError, fn -> UserNameChanges.get_user_name_change!(user_name_change.id) end
|
||||
end
|
||||
|
||||
test "change_user_name_change/1 returns a user_name_change changeset" do
|
||||
user_name_change = user_name_change_fixture()
|
||||
assert %Ecto.Changeset{} = UserNameChanges.change_user_name_change(user_name_change)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.UserStatisticsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.UserStatistics
|
||||
|
||||
describe "user_statistics" do
|
||||
alias Philomena.UserStatistics.UserStatistic
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def user_statistic_fixture(attrs \\ %{}) do
|
||||
{:ok, user_statistic} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> UserStatistics.create_user_statistic()
|
||||
|
||||
user_statistic
|
||||
end
|
||||
|
||||
test "list_user_statistics/0 returns all user_statistics" do
|
||||
user_statistic = user_statistic_fixture()
|
||||
assert UserStatistics.list_user_statistics() == [user_statistic]
|
||||
end
|
||||
|
||||
test "get_user_statistic!/1 returns the user_statistic with given id" do
|
||||
user_statistic = user_statistic_fixture()
|
||||
assert UserStatistics.get_user_statistic!(user_statistic.id) == user_statistic
|
||||
end
|
||||
|
||||
test "create_user_statistic/1 with valid data creates a user_statistic" do
|
||||
assert {:ok, %UserStatistic{} = user_statistic} = UserStatistics.create_user_statistic(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_user_statistic/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = UserStatistics.create_user_statistic(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_user_statistic/2 with valid data updates the user_statistic" do
|
||||
user_statistic = user_statistic_fixture()
|
||||
assert {:ok, %UserStatistic{} = user_statistic} = UserStatistics.update_user_statistic(user_statistic, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_user_statistic/2 with invalid data returns error changeset" do
|
||||
user_statistic = user_statistic_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = UserStatistics.update_user_statistic(user_statistic, @invalid_attrs)
|
||||
assert user_statistic == UserStatistics.get_user_statistic!(user_statistic.id)
|
||||
end
|
||||
|
||||
test "delete_user_statistic/1 deletes the user_statistic" do
|
||||
user_statistic = user_statistic_fixture()
|
||||
assert {:ok, %UserStatistic{}} = UserStatistics.delete_user_statistic(user_statistic)
|
||||
assert_raise Ecto.NoResultsError, fn -> UserStatistics.get_user_statistic!(user_statistic.id) end
|
||||
end
|
||||
|
||||
test "change_user_statistic/1 returns a user_statistic changeset" do
|
||||
user_statistic = user_statistic_fixture()
|
||||
assert %Ecto.Changeset{} = UserStatistics.change_user_statistic(user_statistic)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.UserWhitelistsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.UserWhitelists
|
||||
|
||||
describe "user_whitelists" do
|
||||
alias Philomena.UserWhitelists.UserWhitelist
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def user_whitelist_fixture(attrs \\ %{}) do
|
||||
{:ok, user_whitelist} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> UserWhitelists.create_user_whitelist()
|
||||
|
||||
user_whitelist
|
||||
end
|
||||
|
||||
test "list_user_whitelists/0 returns all user_whitelists" do
|
||||
user_whitelist = user_whitelist_fixture()
|
||||
assert UserWhitelists.list_user_whitelists() == [user_whitelist]
|
||||
end
|
||||
|
||||
test "get_user_whitelist!/1 returns the user_whitelist with given id" do
|
||||
user_whitelist = user_whitelist_fixture()
|
||||
assert UserWhitelists.get_user_whitelist!(user_whitelist.id) == user_whitelist
|
||||
end
|
||||
|
||||
test "create_user_whitelist/1 with valid data creates a user_whitelist" do
|
||||
assert {:ok, %UserWhitelist{} = user_whitelist} = UserWhitelists.create_user_whitelist(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_user_whitelist/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = UserWhitelists.create_user_whitelist(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_user_whitelist/2 with valid data updates the user_whitelist" do
|
||||
user_whitelist = user_whitelist_fixture()
|
||||
assert {:ok, %UserWhitelist{} = user_whitelist} = UserWhitelists.update_user_whitelist(user_whitelist, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_user_whitelist/2 with invalid data returns error changeset" do
|
||||
user_whitelist = user_whitelist_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = UserWhitelists.update_user_whitelist(user_whitelist, @invalid_attrs)
|
||||
assert user_whitelist == UserWhitelists.get_user_whitelist!(user_whitelist.id)
|
||||
end
|
||||
|
||||
test "delete_user_whitelist/1 deletes the user_whitelist" do
|
||||
user_whitelist = user_whitelist_fixture()
|
||||
assert {:ok, %UserWhitelist{}} = UserWhitelists.delete_user_whitelist(user_whitelist)
|
||||
assert_raise Ecto.NoResultsError, fn -> UserWhitelists.get_user_whitelist!(user_whitelist.id) end
|
||||
end
|
||||
|
||||
test "change_user_whitelist/1 returns a user_whitelist changeset" do
|
||||
user_whitelist = user_whitelist_fixture()
|
||||
assert %Ecto.Changeset{} = UserWhitelists.change_user_whitelist(user_whitelist)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,408 +0,0 @@
|
|||
defmodule Philomena.UsersTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Users
|
||||
|
||||
describe "user_ips" do
|
||||
alias Philomena.Users.Ip
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def ip_fixture(attrs \\ %{}) do
|
||||
{:ok, ip} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Users.create_ip()
|
||||
|
||||
ip
|
||||
end
|
||||
|
||||
test "list_user_ips/0 returns all user_ips" do
|
||||
ip = ip_fixture()
|
||||
assert Users.list_user_ips() == [ip]
|
||||
end
|
||||
|
||||
test "get_ip!/1 returns the ip with given id" do
|
||||
ip = ip_fixture()
|
||||
assert Users.get_ip!(ip.id) == ip
|
||||
end
|
||||
|
||||
test "create_ip/1 with valid data creates a ip" do
|
||||
assert {:ok, %Ip{} = ip} = Users.create_ip(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_ip/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Users.create_ip(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_ip/2 with valid data updates the ip" do
|
||||
ip = ip_fixture()
|
||||
assert {:ok, %Ip{} = ip} = Users.update_ip(ip, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_ip/2 with invalid data returns error changeset" do
|
||||
ip = ip_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Users.update_ip(ip, @invalid_attrs)
|
||||
assert ip == Users.get_ip!(ip.id)
|
||||
end
|
||||
|
||||
test "delete_ip/1 deletes the ip" do
|
||||
ip = ip_fixture()
|
||||
assert {:ok, %Ip{}} = Users.delete_ip(ip)
|
||||
assert_raise Ecto.NoResultsError, fn -> Users.get_ip!(ip.id) end
|
||||
end
|
||||
|
||||
test "change_ip/1 returns a ip changeset" do
|
||||
ip = ip_fixture()
|
||||
assert %Ecto.Changeset{} = Users.change_ip(ip)
|
||||
end
|
||||
end
|
||||
|
||||
describe "user_fingerprints" do
|
||||
alias Philomena.Users.Fingerprints
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fingerprints_fixture(attrs \\ %{}) do
|
||||
{:ok, fingerprints} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Users.create_fingerprints()
|
||||
|
||||
fingerprints
|
||||
end
|
||||
|
||||
test "list_user_fingerprints/0 returns all user_fingerprints" do
|
||||
fingerprints = fingerprints_fixture()
|
||||
assert Users.list_user_fingerprints() == [fingerprints]
|
||||
end
|
||||
|
||||
test "get_fingerprints!/1 returns the fingerprints with given id" do
|
||||
fingerprints = fingerprints_fixture()
|
||||
assert Users.get_fingerprints!(fingerprints.id) == fingerprints
|
||||
end
|
||||
|
||||
test "create_fingerprints/1 with valid data creates a fingerprints" do
|
||||
assert {:ok, %Fingerprints{} = fingerprints} = Users.create_fingerprints(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_fingerprints/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Users.create_fingerprints(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_fingerprints/2 with valid data updates the fingerprints" do
|
||||
fingerprints = fingerprints_fixture()
|
||||
|
||||
assert {:ok, %Fingerprints{} = fingerprints} =
|
||||
Users.update_fingerprints(fingerprints, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_fingerprints/2 with invalid data returns error changeset" do
|
||||
fingerprints = fingerprints_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Users.update_fingerprints(fingerprints, @invalid_attrs)
|
||||
assert fingerprints == Users.get_fingerprints!(fingerprints.id)
|
||||
end
|
||||
|
||||
test "delete_fingerprints/1 deletes the fingerprints" do
|
||||
fingerprints = fingerprints_fixture()
|
||||
assert {:ok, %Fingerprints{}} = Users.delete_fingerprints(fingerprints)
|
||||
assert_raise Ecto.NoResultsError, fn -> Users.get_fingerprints!(fingerprints.id) end
|
||||
end
|
||||
|
||||
test "change_fingerprints/1 returns a fingerprints changeset" do
|
||||
fingerprints = fingerprints_fixture()
|
||||
assert %Ecto.Changeset{} = Users.change_fingerprints(fingerprints)
|
||||
end
|
||||
end
|
||||
|
||||
describe "user_links" do
|
||||
alias Philomena.Users.Link
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def link_fixture(attrs \\ %{}) do
|
||||
{:ok, link} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Users.create_link()
|
||||
|
||||
link
|
||||
end
|
||||
|
||||
test "list_user_links/0 returns all user_links" do
|
||||
link = link_fixture()
|
||||
assert Users.list_user_links() == [link]
|
||||
end
|
||||
|
||||
test "get_link!/1 returns the link with given id" do
|
||||
link = link_fixture()
|
||||
assert Users.get_link!(link.id) == link
|
||||
end
|
||||
|
||||
test "create_link/1 with valid data creates a link" do
|
||||
assert {:ok, %Link{} = link} = Users.create_link(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_link/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Users.create_link(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_link/2 with valid data updates the link" do
|
||||
link = link_fixture()
|
||||
assert {:ok, %Link{} = link} = Users.update_link(link, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_link/2 with invalid data returns error changeset" do
|
||||
link = link_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Users.update_link(link, @invalid_attrs)
|
||||
assert link == Users.get_link!(link.id)
|
||||
end
|
||||
|
||||
test "delete_link/1 deletes the link" do
|
||||
link = link_fixture()
|
||||
assert {:ok, %Link{}} = Users.delete_link(link)
|
||||
assert_raise Ecto.NoResultsError, fn -> Users.get_link!(link.id) end
|
||||
end
|
||||
|
||||
test "change_link/1 returns a link changeset" do
|
||||
link = link_fixture()
|
||||
assert %Ecto.Changeset{} = Users.change_link(link)
|
||||
end
|
||||
end
|
||||
|
||||
describe "user_name_changes" do
|
||||
alias Philomena.Users.NameChange
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def name_change_fixture(attrs \\ %{}) do
|
||||
{:ok, name_change} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Users.create_name_change()
|
||||
|
||||
name_change
|
||||
end
|
||||
|
||||
test "list_user_name_changes/0 returns all user_name_changes" do
|
||||
name_change = name_change_fixture()
|
||||
assert Users.list_user_name_changes() == [name_change]
|
||||
end
|
||||
|
||||
test "get_name_change!/1 returns the name_change with given id" do
|
||||
name_change = name_change_fixture()
|
||||
assert Users.get_name_change!(name_change.id) == name_change
|
||||
end
|
||||
|
||||
test "create_name_change/1 with valid data creates a name_change" do
|
||||
assert {:ok, %NameChange{} = name_change} = Users.create_name_change(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_name_change/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Users.create_name_change(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_name_change/2 with valid data updates the name_change" do
|
||||
name_change = name_change_fixture()
|
||||
|
||||
assert {:ok, %NameChange{} = name_change} =
|
||||
Users.update_name_change(name_change, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_name_change/2 with invalid data returns error changeset" do
|
||||
name_change = name_change_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Users.update_name_change(name_change, @invalid_attrs)
|
||||
assert name_change == Users.get_name_change!(name_change.id)
|
||||
end
|
||||
|
||||
test "delete_name_change/1 deletes the name_change" do
|
||||
name_change = name_change_fixture()
|
||||
assert {:ok, %NameChange{}} = Users.delete_name_change(name_change)
|
||||
assert_raise Ecto.NoResultsError, fn -> Users.get_name_change!(name_change.id) end
|
||||
end
|
||||
|
||||
test "change_name_change/1 returns a name_change changeset" do
|
||||
name_change = name_change_fixture()
|
||||
assert %Ecto.Changeset{} = Users.change_name_change(name_change)
|
||||
end
|
||||
end
|
||||
|
||||
describe "user_statistics" do
|
||||
alias Philomena.Users.Statistic
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def statistic_fixture(attrs \\ %{}) do
|
||||
{:ok, statistic} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Users.create_statistic()
|
||||
|
||||
statistic
|
||||
end
|
||||
|
||||
test "list_user_statistics/0 returns all user_statistics" do
|
||||
statistic = statistic_fixture()
|
||||
assert Users.list_user_statistics() == [statistic]
|
||||
end
|
||||
|
||||
test "get_statistic!/1 returns the statistic with given id" do
|
||||
statistic = statistic_fixture()
|
||||
assert Users.get_statistic!(statistic.id) == statistic
|
||||
end
|
||||
|
||||
test "create_statistic/1 with valid data creates a statistic" do
|
||||
assert {:ok, %Statistic{} = statistic} = Users.create_statistic(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_statistic/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Users.create_statistic(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_statistic/2 with valid data updates the statistic" do
|
||||
statistic = statistic_fixture()
|
||||
assert {:ok, %Statistic{} = statistic} = Users.update_statistic(statistic, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_statistic/2 with invalid data returns error changeset" do
|
||||
statistic = statistic_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Users.update_statistic(statistic, @invalid_attrs)
|
||||
assert statistic == Users.get_statistic!(statistic.id)
|
||||
end
|
||||
|
||||
test "delete_statistic/1 deletes the statistic" do
|
||||
statistic = statistic_fixture()
|
||||
assert {:ok, %Statistic{}} = Users.delete_statistic(statistic)
|
||||
assert_raise Ecto.NoResultsError, fn -> Users.get_statistic!(statistic.id) end
|
||||
end
|
||||
|
||||
test "change_statistic/1 returns a statistic changeset" do
|
||||
statistic = statistic_fixture()
|
||||
assert %Ecto.Changeset{} = Users.change_statistic(statistic)
|
||||
end
|
||||
end
|
||||
|
||||
describe "user_whitelists" do
|
||||
alias Philomena.Users.Whitelist
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def whitelist_fixture(attrs \\ %{}) do
|
||||
{:ok, whitelist} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Users.create_whitelist()
|
||||
|
||||
whitelist
|
||||
end
|
||||
|
||||
test "list_user_whitelists/0 returns all user_whitelists" do
|
||||
whitelist = whitelist_fixture()
|
||||
assert Users.list_user_whitelists() == [whitelist]
|
||||
end
|
||||
|
||||
test "get_whitelist!/1 returns the whitelist with given id" do
|
||||
whitelist = whitelist_fixture()
|
||||
assert Users.get_whitelist!(whitelist.id) == whitelist
|
||||
end
|
||||
|
||||
test "create_whitelist/1 with valid data creates a whitelist" do
|
||||
assert {:ok, %Whitelist{} = whitelist} = Users.create_whitelist(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_whitelist/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Users.create_whitelist(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_whitelist/2 with valid data updates the whitelist" do
|
||||
whitelist = whitelist_fixture()
|
||||
assert {:ok, %Whitelist{} = whitelist} = Users.update_whitelist(whitelist, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_whitelist/2 with invalid data returns error changeset" do
|
||||
whitelist = whitelist_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Users.update_whitelist(whitelist, @invalid_attrs)
|
||||
assert whitelist == Users.get_whitelist!(whitelist.id)
|
||||
end
|
||||
|
||||
test "delete_whitelist/1 deletes the whitelist" do
|
||||
whitelist = whitelist_fixture()
|
||||
assert {:ok, %Whitelist{}} = Users.delete_whitelist(whitelist)
|
||||
assert_raise Ecto.NoResultsError, fn -> Users.get_whitelist!(whitelist.id) end
|
||||
end
|
||||
|
||||
test "change_whitelist/1 returns a whitelist changeset" do
|
||||
whitelist = whitelist_fixture()
|
||||
assert %Ecto.Changeset{} = Users.change_whitelist(whitelist)
|
||||
end
|
||||
end
|
||||
|
||||
describe "users_roles" do
|
||||
alias Philomena.Users.Role
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def role_fixture(attrs \\ %{}) do
|
||||
{:ok, role} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Users.create_role()
|
||||
|
||||
role
|
||||
end
|
||||
|
||||
test "list_users_roles/0 returns all users_roles" do
|
||||
role = role_fixture()
|
||||
assert Users.list_users_roles() == [role]
|
||||
end
|
||||
|
||||
test "get_role!/1 returns the role with given id" do
|
||||
role = role_fixture()
|
||||
assert Users.get_role!(role.id) == role
|
||||
end
|
||||
|
||||
test "create_role/1 with valid data creates a role" do
|
||||
assert {:ok, %Role{} = role} = Users.create_role(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_role/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Users.create_role(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_role/2 with valid data updates the role" do
|
||||
role = role_fixture()
|
||||
assert {:ok, %Role{} = role} = Users.update_role(role, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_role/2 with invalid data returns error changeset" do
|
||||
role = role_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Users.update_role(role, @invalid_attrs)
|
||||
assert role == Users.get_role!(role.id)
|
||||
end
|
||||
|
||||
test "delete_role/1 deletes the role" do
|
||||
role = role_fixture()
|
||||
assert {:ok, %Role{}} = Users.delete_role(role)
|
||||
assert_raise Ecto.NoResultsError, fn -> Users.get_role!(role.id) end
|
||||
end
|
||||
|
||||
test "change_role/1 returns a role changeset" do
|
||||
role = role_fixture()
|
||||
assert %Ecto.Changeset{} = Users.change_role(role)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.VersionsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Versions
|
||||
|
||||
describe "versions" do
|
||||
alias Philomena.Versions.Version
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def version_fixture(attrs \\ %{}) do
|
||||
{:ok, version} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Versions.create_version()
|
||||
|
||||
version
|
||||
end
|
||||
|
||||
test "list_versions/0 returns all versions" do
|
||||
version = version_fixture()
|
||||
assert Versions.list_versions() == [version]
|
||||
end
|
||||
|
||||
test "get_version!/1 returns the version with given id" do
|
||||
version = version_fixture()
|
||||
assert Versions.get_version!(version.id) == version
|
||||
end
|
||||
|
||||
test "create_version/1 with valid data creates a version" do
|
||||
assert {:ok, %Version{} = version} = Versions.create_version(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_version/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Versions.create_version(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_version/2 with valid data updates the version" do
|
||||
version = version_fixture()
|
||||
assert {:ok, %Version{} = version} = Versions.update_version(version, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_version/2 with invalid data returns error changeset" do
|
||||
version = version_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Versions.update_version(version, @invalid_attrs)
|
||||
assert version == Versions.get_version!(version.id)
|
||||
end
|
||||
|
||||
test "delete_version/1 deletes the version" do
|
||||
version = version_fixture()
|
||||
assert {:ok, %Version{}} = Versions.delete_version(version)
|
||||
assert_raise Ecto.NoResultsError, fn -> Versions.get_version!(version.id) end
|
||||
end
|
||||
|
||||
test "change_version/1 returns a version changeset" do
|
||||
version = version_fixture()
|
||||
assert %Ecto.Changeset{} = Versions.change_version(version)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
defmodule Philomena.VpnsTest do
|
||||
use Philomena.DataCase
|
||||
|
||||
alias Philomena.Vpns
|
||||
|
||||
describe "vpns" do
|
||||
alias Philomena.Vpns.Vpn
|
||||
|
||||
@valid_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def vpn_fixture(attrs \\ %{}) do
|
||||
{:ok, vpn} =
|
||||
attrs
|
||||
|> Enum.into(@valid_attrs)
|
||||
|> Vpns.create_vpn()
|
||||
|
||||
vpn
|
||||
end
|
||||
|
||||
test "list_vpns/0 returns all vpns" do
|
||||
vpn = vpn_fixture()
|
||||
assert Vpns.list_vpns() == [vpn]
|
||||
end
|
||||
|
||||
test "get_vpn!/1 returns the vpn with given id" do
|
||||
vpn = vpn_fixture()
|
||||
assert Vpns.get_vpn!(vpn.id) == vpn
|
||||
end
|
||||
|
||||
test "create_vpn/1 with valid data creates a vpn" do
|
||||
assert {:ok, %Vpn{} = vpn} = Vpns.create_vpn(@valid_attrs)
|
||||
end
|
||||
|
||||
test "create_vpn/1 with invalid data returns error changeset" do
|
||||
assert {:error, %Ecto.Changeset{}} = Vpns.create_vpn(@invalid_attrs)
|
||||
end
|
||||
|
||||
test "update_vpn/2 with valid data updates the vpn" do
|
||||
vpn = vpn_fixture()
|
||||
assert {:ok, %Vpn{} = vpn} = Vpns.update_vpn(vpn, @update_attrs)
|
||||
end
|
||||
|
||||
test "update_vpn/2 with invalid data returns error changeset" do
|
||||
vpn = vpn_fixture()
|
||||
assert {:error, %Ecto.Changeset{}} = Vpns.update_vpn(vpn, @invalid_attrs)
|
||||
assert vpn == Vpns.get_vpn!(vpn.id)
|
||||
end
|
||||
|
||||
test "delete_vpn/1 deletes the vpn" do
|
||||
vpn = vpn_fixture()
|
||||
assert {:ok, %Vpn{}} = Vpns.delete_vpn(vpn)
|
||||
assert_raise Ecto.NoResultsError, fn -> Vpns.get_vpn!(vpn.id) end
|
||||
end
|
||||
|
||||
test "change_vpn/1 returns a vpn changeset" do
|
||||
vpn = vpn_fixture()
|
||||
assert %Ecto.Changeset{} = Vpns.change_vpn(vpn)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
defmodule PhilomenaWeb.ChannelControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.Channels
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:channel) do
|
||||
{:ok, channel} = Channels.create_channel(@create_attrs)
|
||||
channel
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all channels", %{conn: conn} do
|
||||
conn = get(conn, Routes.channel_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Channels"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new channel" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.channel_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Channel"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create channel" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.channel_path(conn, :create), channel: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.channel_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.channel_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Channel"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.channel_path(conn, :create), channel: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Channel"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit channel" do
|
||||
setup [:create_channel]
|
||||
|
||||
test "renders form for editing chosen channel", %{conn: conn, channel: channel} do
|
||||
conn = get(conn, Routes.channel_path(conn, :edit, channel))
|
||||
assert html_response(conn, 200) =~ "Edit Channel"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update channel" do
|
||||
setup [:create_channel]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, channel: channel} do
|
||||
conn = put(conn, Routes.channel_path(conn, :update, channel), channel: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.channel_path(conn, :show, channel)
|
||||
|
||||
conn = get(conn, Routes.channel_path(conn, :show, channel))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, channel: channel} do
|
||||
conn = put(conn, Routes.channel_path(conn, :update, channel), channel: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Channel"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete channel" do
|
||||
setup [:create_channel]
|
||||
|
||||
test "deletes chosen channel", %{conn: conn, channel: channel} do
|
||||
conn = delete(conn, Routes.channel_path(conn, :delete, channel))
|
||||
assert redirected_to(conn) == Routes.channel_path(conn, :index)
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.channel_path(conn, :show, channel))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_channel(_) do
|
||||
channel = fixture(:channel)
|
||||
{:ok, channel: channel}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
defmodule PhilomenaWeb.CommentControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.Comments
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:comment) do
|
||||
{:ok, comment} = Comments.create_comment(@create_attrs)
|
||||
comment
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all comments", %{conn: conn} do
|
||||
conn = get(conn, Routes.comment_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Comments"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new comment" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.comment_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Comment"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create comment" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.comment_path(conn, :create), comment: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.comment_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.comment_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Comment"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.comment_path(conn, :create), comment: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Comment"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit comment" do
|
||||
setup [:create_comment]
|
||||
|
||||
test "renders form for editing chosen comment", %{conn: conn, comment: comment} do
|
||||
conn = get(conn, Routes.comment_path(conn, :edit, comment))
|
||||
assert html_response(conn, 200) =~ "Edit Comment"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update comment" do
|
||||
setup [:create_comment]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, comment: comment} do
|
||||
conn = put(conn, Routes.comment_path(conn, :update, comment), comment: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.comment_path(conn, :show, comment)
|
||||
|
||||
conn = get(conn, Routes.comment_path(conn, :show, comment))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, comment: comment} do
|
||||
conn = put(conn, Routes.comment_path(conn, :update, comment), comment: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Comment"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete comment" do
|
||||
setup [:create_comment]
|
||||
|
||||
test "deletes chosen comment", %{conn: conn, comment: comment} do
|
||||
conn = delete(conn, Routes.comment_path(conn, :delete, comment))
|
||||
assert redirected_to(conn) == Routes.comment_path(conn, :index)
|
||||
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.comment_path(conn, :show, comment))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_comment(_) do
|
||||
comment = fixture(:comment)
|
||||
{:ok, comment: comment}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
defmodule PhilomenaWeb.DnpEntryControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.DnpEntries
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:dnp_entry) do
|
||||
{:ok, dnp_entry} = DnpEntries.create_dnp_entry(@create_attrs)
|
||||
dnp_entry
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all dnp_entries", %{conn: conn} do
|
||||
conn = get(conn, Routes.dnp_entry_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Dnp entries"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new dnp_entry" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.dnp_entry_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Dnp entry"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create dnp_entry" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.dnp_entry_path(conn, :create), dnp_entry: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.dnp_entry_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.dnp_entry_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Dnp entry"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.dnp_entry_path(conn, :create), dnp_entry: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Dnp entry"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit dnp_entry" do
|
||||
setup [:create_dnp_entry]
|
||||
|
||||
test "renders form for editing chosen dnp_entry", %{conn: conn, dnp_entry: dnp_entry} do
|
||||
conn = get(conn, Routes.dnp_entry_path(conn, :edit, dnp_entry))
|
||||
assert html_response(conn, 200) =~ "Edit Dnp entry"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update dnp_entry" do
|
||||
setup [:create_dnp_entry]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, dnp_entry: dnp_entry} do
|
||||
conn = put(conn, Routes.dnp_entry_path(conn, :update, dnp_entry), dnp_entry: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.dnp_entry_path(conn, :show, dnp_entry)
|
||||
|
||||
conn = get(conn, Routes.dnp_entry_path(conn, :show, dnp_entry))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, dnp_entry: dnp_entry} do
|
||||
conn = put(conn, Routes.dnp_entry_path(conn, :update, dnp_entry), dnp_entry: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Dnp entry"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete dnp_entry" do
|
||||
setup [:create_dnp_entry]
|
||||
|
||||
test "deletes chosen dnp_entry", %{conn: conn, dnp_entry: dnp_entry} do
|
||||
conn = delete(conn, Routes.dnp_entry_path(conn, :delete, dnp_entry))
|
||||
assert redirected_to(conn) == Routes.dnp_entry_path(conn, :index)
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.dnp_entry_path(conn, :show, dnp_entry))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_dnp_entry(_) do
|
||||
dnp_entry = fixture(:dnp_entry)
|
||||
{:ok, dnp_entry: dnp_entry}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
defmodule PhilomenaWeb.DuplicateReportControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.DuplicateReports
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:duplicate_report) do
|
||||
{:ok, duplicate_report} = DuplicateReports.create_duplicate_report(@create_attrs)
|
||||
duplicate_report
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all duplicate_reports", %{conn: conn} do
|
||||
conn = get(conn, Routes.duplicate_report_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Duplicate reports"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new duplicate_report" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.duplicate_report_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Duplicate report"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create duplicate_report" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.duplicate_report_path(conn, :create), duplicate_report: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.duplicate_report_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.duplicate_report_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Duplicate report"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.duplicate_report_path(conn, :create), duplicate_report: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Duplicate report"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit duplicate_report" do
|
||||
setup [:create_duplicate_report]
|
||||
|
||||
test "renders form for editing chosen duplicate_report", %{conn: conn, duplicate_report: duplicate_report} do
|
||||
conn = get(conn, Routes.duplicate_report_path(conn, :edit, duplicate_report))
|
||||
assert html_response(conn, 200) =~ "Edit Duplicate report"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update duplicate_report" do
|
||||
setup [:create_duplicate_report]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, duplicate_report: duplicate_report} do
|
||||
conn = put(conn, Routes.duplicate_report_path(conn, :update, duplicate_report), duplicate_report: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.duplicate_report_path(conn, :show, duplicate_report)
|
||||
|
||||
conn = get(conn, Routes.duplicate_report_path(conn, :show, duplicate_report))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, duplicate_report: duplicate_report} do
|
||||
conn = put(conn, Routes.duplicate_report_path(conn, :update, duplicate_report), duplicate_report: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Duplicate report"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete duplicate_report" do
|
||||
setup [:create_duplicate_report]
|
||||
|
||||
test "deletes chosen duplicate_report", %{conn: conn, duplicate_report: duplicate_report} do
|
||||
conn = delete(conn, Routes.duplicate_report_path(conn, :delete, duplicate_report))
|
||||
assert redirected_to(conn) == Routes.duplicate_report_path(conn, :index)
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.duplicate_report_path(conn, :show, duplicate_report))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_duplicate_report(_) do
|
||||
duplicate_report = fixture(:duplicate_report)
|
||||
{:ok, duplicate_report: duplicate_report}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
defmodule PhilomenaWeb.ImageControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.Images
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:image) do
|
||||
{:ok, image} = Images.create_image(@create_attrs)
|
||||
image
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all images", %{conn: conn} do
|
||||
conn = get(conn, Routes.image_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Images"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new image" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.image_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Image"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create image" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.image_path(conn, :create), image: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.image_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.image_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Image"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.image_path(conn, :create), image: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Image"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit image" do
|
||||
setup [:create_image]
|
||||
|
||||
test "renders form for editing chosen image", %{conn: conn, image: image} do
|
||||
conn = get(conn, Routes.image_path(conn, :edit, image))
|
||||
assert html_response(conn, 200) =~ "Edit Image"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update image" do
|
||||
setup [:create_image]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, image: image} do
|
||||
conn = put(conn, Routes.image_path(conn, :update, image), image: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.image_path(conn, :show, image)
|
||||
|
||||
conn = get(conn, Routes.image_path(conn, :show, image))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, image: image} do
|
||||
conn = put(conn, Routes.image_path(conn, :update, image), image: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Image"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete image" do
|
||||
setup [:create_image]
|
||||
|
||||
test "deletes chosen image", %{conn: conn, image: image} do
|
||||
conn = delete(conn, Routes.image_path(conn, :delete, image))
|
||||
assert redirected_to(conn) == Routes.image_path(conn, :index)
|
||||
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.image_path(conn, :show, image))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_image(_) do
|
||||
image = fixture(:image)
|
||||
{:ok, image: image}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
defmodule PhilomenaWeb.PageControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
test "GET /", %{conn: conn} do
|
||||
conn = get(conn, "/")
|
||||
assert html_response(conn, 200) =~ "Welcome to Phoenix!"
|
||||
end
|
||||
end
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
defmodule PhilomenaWeb.SettingControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.Settings
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:setting) do
|
||||
{:ok, setting} = Settings.create_setting(@create_attrs)
|
||||
setting
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all settings", %{conn: conn} do
|
||||
conn = get(conn, Routes.setting_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Settings"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new setting" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.setting_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Setting"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create setting" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.setting_path(conn, :create), setting: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.setting_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.setting_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Setting"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.setting_path(conn, :create), setting: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Setting"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit setting" do
|
||||
setup [:create_setting]
|
||||
|
||||
test "renders form for editing chosen setting", %{conn: conn, setting: setting} do
|
||||
conn = get(conn, Routes.setting_path(conn, :edit, setting))
|
||||
assert html_response(conn, 200) =~ "Edit Setting"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update setting" do
|
||||
setup [:create_setting]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, setting: setting} do
|
||||
conn = put(conn, Routes.setting_path(conn, :update, setting), setting: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.setting_path(conn, :show, setting)
|
||||
|
||||
conn = get(conn, Routes.setting_path(conn, :show, setting))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, setting: setting} do
|
||||
conn = put(conn, Routes.setting_path(conn, :update, setting), setting: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Setting"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete setting" do
|
||||
setup [:create_setting]
|
||||
|
||||
test "deletes chosen setting", %{conn: conn, setting: setting} do
|
||||
conn = delete(conn, Routes.setting_path(conn, :delete, setting))
|
||||
assert redirected_to(conn) == Routes.setting_path(conn, :index)
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.setting_path(conn, :show, setting))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_setting(_) do
|
||||
setting = fixture(:setting)
|
||||
{:ok, setting: setting}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
defmodule PhilomenaWeb.StaffControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.Staffs
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:staff) do
|
||||
{:ok, staff} = Staffs.create_staff(@create_attrs)
|
||||
staff
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all staffs", %{conn: conn} do
|
||||
conn = get(conn, Routes.staff_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Staffs"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new staff" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.staff_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Staff"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create staff" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.staff_path(conn, :create), staff: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.staff_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.staff_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Staff"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.staff_path(conn, :create), staff: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Staff"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit staff" do
|
||||
setup [:create_staff]
|
||||
|
||||
test "renders form for editing chosen staff", %{conn: conn, staff: staff} do
|
||||
conn = get(conn, Routes.staff_path(conn, :edit, staff))
|
||||
assert html_response(conn, 200) =~ "Edit Staff"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update staff" do
|
||||
setup [:create_staff]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, staff: staff} do
|
||||
conn = put(conn, Routes.staff_path(conn, :update, staff), staff: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.staff_path(conn, :show, staff)
|
||||
|
||||
conn = get(conn, Routes.staff_path(conn, :show, staff))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, staff: staff} do
|
||||
conn = put(conn, Routes.staff_path(conn, :update, staff), staff: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Staff"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete staff" do
|
||||
setup [:create_staff]
|
||||
|
||||
test "deletes chosen staff", %{conn: conn, staff: staff} do
|
||||
conn = delete(conn, Routes.staff_path(conn, :delete, staff))
|
||||
assert redirected_to(conn) == Routes.staff_path(conn, :index)
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.staff_path(conn, :show, staff))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_staff(_) do
|
||||
staff = fixture(:staff)
|
||||
{:ok, staff: staff}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
defmodule PhilomenaWeb.StatControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.Stats
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:stat) do
|
||||
{:ok, stat} = Stats.create_stat(@create_attrs)
|
||||
stat
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all stats", %{conn: conn} do
|
||||
conn = get(conn, Routes.stat_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Stats"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new stat" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.stat_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Stat"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create stat" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.stat_path(conn, :create), stat: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.stat_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.stat_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Stat"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.stat_path(conn, :create), stat: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Stat"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit stat" do
|
||||
setup [:create_stat]
|
||||
|
||||
test "renders form for editing chosen stat", %{conn: conn, stat: stat} do
|
||||
conn = get(conn, Routes.stat_path(conn, :edit, stat))
|
||||
assert html_response(conn, 200) =~ "Edit Stat"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update stat" do
|
||||
setup [:create_stat]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, stat: stat} do
|
||||
conn = put(conn, Routes.stat_path(conn, :update, stat), stat: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.stat_path(conn, :show, stat)
|
||||
|
||||
conn = get(conn, Routes.stat_path(conn, :show, stat))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, stat: stat} do
|
||||
conn = put(conn, Routes.stat_path(conn, :update, stat), stat: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Stat"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete stat" do
|
||||
setup [:create_stat]
|
||||
|
||||
test "deletes chosen stat", %{conn: conn, stat: stat} do
|
||||
conn = delete(conn, Routes.stat_path(conn, :delete, stat))
|
||||
assert redirected_to(conn) == Routes.stat_path(conn, :index)
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.stat_path(conn, :show, stat))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_stat(_) do
|
||||
stat = fixture(:stat)
|
||||
{:ok, stat: stat}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
defmodule PhilomenaWeb.TagControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.Tags
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:tag) do
|
||||
{:ok, tag} = Tags.create_tag(@create_attrs)
|
||||
tag
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all tags", %{conn: conn} do
|
||||
conn = get(conn, Routes.tag_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing Tags"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new tag" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.tag_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New Tag"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create tag" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.tag_path(conn, :create), tag: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.tag_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.tag_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show Tag"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.tag_path(conn, :create), tag: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New Tag"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit tag" do
|
||||
setup [:create_tag]
|
||||
|
||||
test "renders form for editing chosen tag", %{conn: conn, tag: tag} do
|
||||
conn = get(conn, Routes.tag_path(conn, :edit, tag))
|
||||
assert html_response(conn, 200) =~ "Edit Tag"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update tag" do
|
||||
setup [:create_tag]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, tag: tag} do
|
||||
conn = put(conn, Routes.tag_path(conn, :update, tag), tag: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.tag_path(conn, :show, tag)
|
||||
|
||||
conn = get(conn, Routes.tag_path(conn, :show, tag))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, tag: tag} do
|
||||
conn = put(conn, Routes.tag_path(conn, :update, tag), tag: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit Tag"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete tag" do
|
||||
setup [:create_tag]
|
||||
|
||||
test "deletes chosen tag", %{conn: conn, tag: tag} do
|
||||
conn = delete(conn, Routes.tag_path(conn, :delete, tag))
|
||||
assert redirected_to(conn) == Routes.tag_path(conn, :index)
|
||||
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.tag_path(conn, :show, tag))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_tag(_) do
|
||||
tag = fixture(:tag)
|
||||
{:ok, tag: tag}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
defmodule PhilomenaWeb.UserLinkControllerTest do
|
||||
use PhilomenaWeb.ConnCase
|
||||
|
||||
alias Philomena.UserLinks
|
||||
|
||||
@create_attrs %{}
|
||||
@update_attrs %{}
|
||||
@invalid_attrs %{}
|
||||
|
||||
def fixture(:user_link) do
|
||||
{:ok, user_link} = UserLinks.create_user_link(@create_attrs)
|
||||
user_link
|
||||
end
|
||||
|
||||
describe "index" do
|
||||
test "lists all user_links", %{conn: conn} do
|
||||
conn = get(conn, Routes.user_link_path(conn, :index))
|
||||
assert html_response(conn, 200) =~ "Listing User links"
|
||||
end
|
||||
end
|
||||
|
||||
describe "new user_link" do
|
||||
test "renders form", %{conn: conn} do
|
||||
conn = get(conn, Routes.user_link_path(conn, :new))
|
||||
assert html_response(conn, 200) =~ "New User link"
|
||||
end
|
||||
end
|
||||
|
||||
describe "create user_link" do
|
||||
test "redirects to show when data is valid", %{conn: conn} do
|
||||
conn = post(conn, Routes.user_link_path(conn, :create), user_link: @create_attrs)
|
||||
|
||||
assert %{id: id} = redirected_params(conn)
|
||||
assert redirected_to(conn) == Routes.user_link_path(conn, :show, id)
|
||||
|
||||
conn = get(conn, Routes.user_link_path(conn, :show, id))
|
||||
assert html_response(conn, 200) =~ "Show User link"
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn} do
|
||||
conn = post(conn, Routes.user_link_path(conn, :create), user_link: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "New User link"
|
||||
end
|
||||
end
|
||||
|
||||
describe "edit user_link" do
|
||||
setup [:create_user_link]
|
||||
|
||||
test "renders form for editing chosen user_link", %{conn: conn, user_link: user_link} do
|
||||
conn = get(conn, Routes.user_link_path(conn, :edit, user_link))
|
||||
assert html_response(conn, 200) =~ "Edit User link"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update user_link" do
|
||||
setup [:create_user_link]
|
||||
|
||||
test "redirects when data is valid", %{conn: conn, user_link: user_link} do
|
||||
conn = put(conn, Routes.user_link_path(conn, :update, user_link), user_link: @update_attrs)
|
||||
assert redirected_to(conn) == Routes.user_link_path(conn, :show, user_link)
|
||||
|
||||
conn = get(conn, Routes.user_link_path(conn, :show, user_link))
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "renders errors when data is invalid", %{conn: conn, user_link: user_link} do
|
||||
conn = put(conn, Routes.user_link_path(conn, :update, user_link), user_link: @invalid_attrs)
|
||||
assert html_response(conn, 200) =~ "Edit User link"
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete user_link" do
|
||||
setup [:create_user_link]
|
||||
|
||||
test "deletes chosen user_link", %{conn: conn, user_link: user_link} do
|
||||
conn = delete(conn, Routes.user_link_path(conn, :delete, user_link))
|
||||
assert redirected_to(conn) == Routes.user_link_path(conn, :index)
|
||||
assert_error_sent 404, fn ->
|
||||
get(conn, Routes.user_link_path(conn, :show, user_link))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
defp create_user_link(_) do
|
||||
user_link = fixture(:user_link)
|
||||
{:ok, user_link: user_link}
|
||||
end
|
||||
end
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
defmodule PhilomenaWeb.ErrorViewTest do
|
||||
use PhilomenaWeb.ConnCase, async: true
|
||||
|
||||
# Bring render/3 and render_to_string/3 for testing custom views
|
||||
import Phoenix.View
|
||||
|
||||
test "renders 404.html" do
|
||||
assert render_to_string(PhilomenaWeb.ErrorView, "404.html", []) == "Not Found"
|
||||
end
|
||||
|
||||
test "renders 500.html" do
|
||||
assert render_to_string(PhilomenaWeb.ErrorView, "500.html", []) == "Internal Server Error"
|
||||
end
|
||||
end
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
defmodule PhilomenaWeb.LayoutViewTest do
|
||||
use PhilomenaWeb.ConnCase, async: true
|
||||
end
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
defmodule PhilomenaWeb.PageViewTest do
|
||||
use PhilomenaWeb.ConnCase, async: true
|
||||
end
|
||||
Loading…
Reference in a new issue