cf8b8207e2
Change how artist URLs are normalized in artist entries. Don't try to secretly convert image URLs to profile URLs in artist entries. For example, if someone puts a Pixiv image URL in an artist entry, don't secretly try to fetch the source and convert it into a profile URL in the `normalized_url` field. We did this because years ago, it was standard practice to put image URLs in artist entries. Pixiv image URLs used to contain the artist's username, so we used to put image URLs in artist entries for artist finding purposes. But Pixiv changed it so that image URLs no longer contained the username, so we dealt with it by adding a `normalized_url` column to artist_urls and secretly converting image URLs to profile URLs in this field. But this is no longer necessary because now we don't normally put image URLs in artist entries in the first place. Now the `profile_url` method in `Source::URL` is used to normalize URLs in artist entries. This lets us parse various profile URL formats and normalize them into a single canonical form. This also removes the `normalize_for_artist_finder` method from source strategies. Instead the `profile_url` method is used for artist finding purposes. So the profile URL returned by the source strategy needs to be the same as the URL in the artist entry in order for artist finding to work.
626 lines
28 KiB
Ruby
626 lines
28 KiB
Ruby
require 'test_helper'
|
|
|
|
class ArtistTest < ActiveSupport::TestCase
|
|
def assert_artist_found(expected_name, source_url)
|
|
artists = Artist.search(url_matches: source_url).to_a
|
|
|
|
assert_equal(1, artists.size)
|
|
assert_equal(expected_name, artists.first.name, "Testing URL: #{source_url}")
|
|
end
|
|
|
|
def assert_artist_not_found(source_url)
|
|
artists = Artist.search(url_matches: source_url).to_a
|
|
assert_equal(0, artists.size, "Testing URL: #{source_url}")
|
|
end
|
|
|
|
context "An artist" do
|
|
setup do
|
|
user = travel_to(1.month.ago) {FactoryBot.create(:user)}
|
|
CurrentUser.user = user
|
|
CurrentUser.ip_addr = "127.0.0.1"
|
|
end
|
|
|
|
teardown do
|
|
CurrentUser.user = nil
|
|
CurrentUser.ip_addr = nil
|
|
end
|
|
|
|
should "parse inactive urls" do
|
|
@artist = create(:artist, name: "blah", url_string: "-http://monet.com")
|
|
assert_equal(["-http://monet.com"], @artist.urls.map(&:to_s))
|
|
refute(@artist.urls[0].is_active?)
|
|
end
|
|
|
|
should "not allow duplicate active+inactive urls" do
|
|
@artist = create(:artist, name: "blah", url_string: "-http://monet.com\nhttp://monet.com")
|
|
assert_equal(1, @artist.urls.count)
|
|
assert_equal(["-http://monet.com"], @artist.urls.map(&:to_s))
|
|
refute(@artist.urls[0].is_active?)
|
|
end
|
|
|
|
should "allow deactivating a url" do
|
|
@artist = create(:artist, name: "blah", url_string: "http://monet.com")
|
|
@artist.update(url_string: "-http://monet.com")
|
|
assert_equal(1, @artist.urls.count)
|
|
refute(@artist.urls[0].is_active?)
|
|
end
|
|
|
|
should "allow activating a url" do
|
|
@artist = create(:artist, name: "blah", url_string: "-http://monet.com")
|
|
@artist.update(url_string: "http://monet.com")
|
|
assert_equal(1, @artist.urls.count)
|
|
assert(@artist.urls[0].is_active?)
|
|
end
|
|
|
|
context "with an invalid name" do
|
|
subject { FactoryBot.build(:artist) }
|
|
|
|
should_not allow_value("-blah").for(:name)
|
|
should_not allow_value("_").for(:name)
|
|
should_not allow_value("").for(:name)
|
|
end
|
|
|
|
context "that has been banned" do
|
|
setup do
|
|
@artist = FactoryBot.create(:artist, :name => "aaa")
|
|
@post = FactoryBot.create(:post, :tag_string => "aaa")
|
|
@admin = FactoryBot.create(:admin_user)
|
|
@artist.ban!(banner: @admin)
|
|
perform_enqueued_jobs
|
|
@post.reload
|
|
end
|
|
|
|
should "allow unbanning" do
|
|
assert_equal(true, @artist.reload.is_banned?)
|
|
assert_equal(true, @post.reload.is_banned?)
|
|
assert_equal(true, @artist.versions.last.is_banned?)
|
|
|
|
assert_difference("TagImplication.count", -1) do
|
|
@artist.unban!
|
|
end
|
|
|
|
assert_equal(false, @artist.reload.is_banned?)
|
|
assert_equal(false, @post.reload.is_banned?)
|
|
assert_equal(false, @artist.versions.last.is_banned?)
|
|
assert_equal("aaa", @post.tag_string)
|
|
end
|
|
|
|
should "ban the post" do
|
|
assert(@post.is_banned?)
|
|
end
|
|
|
|
should "not delete the post" do
|
|
refute(@post.is_deleted?)
|
|
end
|
|
|
|
should "create a new tag implication" do
|
|
assert_equal(1, TagImplication.where(:antecedent_name => "aaa", :consequent_name => "banned_artist").count)
|
|
assert_equal("aaa banned_artist", @post.reload.tag_string)
|
|
end
|
|
|
|
should "set the approver of the banned_artist implication" do
|
|
ta = TagImplication.where(:antecedent_name => "aaa", :consequent_name => "banned_artist").first
|
|
assert_equal(@admin.id, ta.approver.id)
|
|
end
|
|
|
|
should "update the artist history" do
|
|
assert_equal(true, @artist.versions.last.is_banned?)
|
|
end
|
|
end
|
|
|
|
should "normalize its name" do
|
|
artist = FactoryBot.create(:artist, :name => " AAA BBB ")
|
|
assert_equal("aaa_bbb", artist.name)
|
|
end
|
|
|
|
should "resolve ambiguous urls" do
|
|
bobross = FactoryBot.create(:artist, :name => "bob_ross", :url_string => "http://artists.com/bobross/image.jpg")
|
|
bob = FactoryBot.create(:artist, :name => "bob", :url_string => "http://artists.com/bob/image.jpg")
|
|
assert_artist_found("bob", "http://artists.com/bob/test.jpg")
|
|
end
|
|
|
|
should "parse urls" do
|
|
artist = FactoryBot.create(:artist, :name => "rembrandt", :url_string => "http://rembrandt.com/test.jpg http://aaa.com")
|
|
artist.reload
|
|
assert_equal(["http://aaa.com", "http://rembrandt.com/test.jpg"], artist.urls.map(&:to_s).sort)
|
|
end
|
|
|
|
should "not allow invalid urls" do
|
|
artist = FactoryBot.build(:artist, :url_string => "blah")
|
|
assert_equal(false, artist.valid?)
|
|
assert_includes(artist.errors["urls.url"], "'blah' must begin with http:// or https:// ")
|
|
assert_includes(artist.errors["urls.url"], "'blah' has a hostname '' that does not contain a dot")
|
|
end
|
|
|
|
should "allow fixing invalid urls" do
|
|
artist = FactoryBot.build(:artist)
|
|
artist.urls << FactoryBot.build(:artist_url, url: "www.example.com", normalized_url: "www.example.com")
|
|
artist.save(validate: false)
|
|
|
|
artist.update(url_string: "http://www.example.com")
|
|
assert_equal(true, artist.valid?)
|
|
assert_equal("http://www.example.com", artist.urls.map(&:to_s).join)
|
|
end
|
|
|
|
should "make sure old urls are deleted" do
|
|
artist = FactoryBot.create(:artist, :name => "rembrandt", :url_string => "http://rembrandt.com/test.jpg")
|
|
artist.url_string = "http://not.rembrandt.com/test.jpg"
|
|
artist.save
|
|
artist.reload
|
|
assert_equal(["http://not.rembrandt.com/test.jpg"], artist.urls.map(&:to_s).sort)
|
|
end
|
|
|
|
should "not delete urls that have not changed" do
|
|
artist = FactoryBot.create(:artist, :name => "rembrandt", :url_string => "http://rembrandt.com/test.jpg")
|
|
old_url_ids = ArtistURL.order("id").pluck(&:id)
|
|
artist.url_string = "http://rembrandt.com/test.jpg"
|
|
artist.save
|
|
assert_equal(old_url_ids, ArtistURL.order("id").pluck(&:id))
|
|
end
|
|
|
|
should "normalize urls before removing duplicates" do
|
|
@artist = create(:artist, url_string: "https://Twitter.com/o8q https://twitter.com/o8q")
|
|
|
|
assert_equal(1, @artist.urls.count)
|
|
assert_equal(["https://twitter.com/o8q"], @artist.urls.map(&:to_s))
|
|
end
|
|
|
|
should "ignore pixiv.net/ and pixiv.net/img/ url matches" do
|
|
a1 = FactoryBot.create(:artist, :name => "yomosaka", :url_string => "http://i2.pixiv.net/img18/img/evazion/14901720.png")
|
|
a2 = FactoryBot.create(:artist, :name => "niwatazumi_bf", :url_string => "http://i2.pixiv.net/img18/img/evazion/14901720_big_p0.png")
|
|
assert_artist_not_found("http://i2.pixiv.net/img28/img/kyang692/35563903.jpg")
|
|
end
|
|
|
|
should "ignore /en/ pixiv url matches" do
|
|
a1 = FactoryBot.create(:artist, :name => "vvv", :url_string => "https://www.pixiv.net/en/users/32072927/artworks")
|
|
a2 = FactoryBot.create(:artist, :name => "c01a", :url_string => "https://www.pixiv.net/en/users/31744504")
|
|
assert_artist_not_found("https://www.pixiv.net/en/artworks/85241178")
|
|
assert_artist_not_found("https://www.pixiv.net/en/users/85241178")
|
|
end
|
|
|
|
should "find matches by url" do
|
|
a1 = FactoryBot.create(:artist, :name => "rembrandt", :url_string => "http://rembrandt.com/x/test.jpg")
|
|
a2 = FactoryBot.create(:artist, :name => "subway", :url_string => "http://subway.com/x/test.jpg")
|
|
a3 = FactoryBot.create(:artist, :name => "minko", :url_string => "https://minko.com/x/test.jpg")
|
|
|
|
assert_artist_found("rembrandt", "http://rembrandt.com/x/test.jpg")
|
|
assert_artist_found("rembrandt", "http://rembrandt.com/x/another.jpg")
|
|
assert_artist_not_found("http://nonexistent.com/test.jpg")
|
|
assert_artist_found("minko", "https://minko.com/x/test.jpg")
|
|
assert_artist_found("minko", "http://minko.com/x/test.jpg")
|
|
end
|
|
|
|
should "be case-insensitive to domains when finding matches by url" do
|
|
a1 = FactoryBot.create(:artist, name: "bkub", url_string: "http://BKUB.example.com")
|
|
assert_artist_found(a1.name, "http://bkub.example.com")
|
|
end
|
|
|
|
should "not find duplicates" do
|
|
FactoryBot.create(:artist, :name => "warhol", :url_string => "http://warhol.com/x/a/image.jpg\nhttp://warhol.com/x/b/image.jpg")
|
|
assert_artist_found("warhol", "http://warhol.com/x/test.jpg")
|
|
end
|
|
|
|
should "not include duplicate urls" do
|
|
artist = FactoryBot.create(:artist, :url_string => "http://foo.com http://foo.com")
|
|
assert_equal(["http://foo.com"], artist.url_array)
|
|
end
|
|
|
|
should "hide deleted artists" do
|
|
create(:artist, name: "warhol", url_string: "http://warhol.com/a/image.jpg", is_deleted: true)
|
|
assert_artist_not_found("http://warhol.com/a/image.jpg")
|
|
end
|
|
|
|
context "when finding deviantart artists" do
|
|
setup do
|
|
skip "DeviantArt API keys not set" unless Danbooru.config.deviantart_client_id.present?
|
|
FactoryBot.create(:artist, :name => "artgerm", :url_string => "http://artgerm.deviantart.com/")
|
|
FactoryBot.create(:artist, :name => "trixia", :url_string => "http://trixdraws.deviantart.com/")
|
|
end
|
|
|
|
should "find the correct artist for page URLs" do
|
|
assert_artist_found("artgerm", "http://www.deviantart.com/artgerm/art/Peachy-Princess-Ver-2-457220550")
|
|
assert_artist_found("trixia", "http://www.deviantart.com/trixdraws/art/My-Queen-426745289")
|
|
end
|
|
|
|
should "find the correct artist for image URLs" do
|
|
assert_artist_found("artgerm", "http://th05.deviantart.net/fs71/200H/f/2014/150/d/c/peachy_princess_by_artgerm-d7k7tmu.jpg")
|
|
assert_artist_found("artgerm", "http://th05.deviantart.net/fs71/PRE/f/2014/150/d/c/peachy_princess_by_artgerm-d7k7tmu.jpg")
|
|
assert_artist_found("artgerm", "http://fc06.deviantart.net/fs71/f/2014/150/d/c/peachy_princess_by_artgerm-d7k7tmu.jpg")
|
|
|
|
assert_artist_found("trixia", "http://fc01.deviantart.net/fs71/i/2014/050/d/e/my_queen_by_trixdraws-d722mrt.jpg")
|
|
assert_artist_found("trixia", "http://th01.deviantart.net/fs71/200H/i/2014/050/d/e/my_queen_by_trixdraws-d722mrt.jpg")
|
|
assert_artist_found("trixia", "http://th09.deviantart.net/fs71/PRE/i/2014/050/d/e/my_queen_by_trixdraws-d722mrt.jpg")
|
|
end
|
|
end
|
|
|
|
context "when finding pixiv artists" do
|
|
setup do
|
|
FactoryBot.create(:artist, :name => "masao", :url_string => "http://www.pixiv.net/member.php?id=32777")
|
|
FactoryBot.create(:artist, :name => "bkub", :url_string => "http://www.pixiv.net/member.php?id=9948")
|
|
FactoryBot.create(:artist, :name => "ryuura", :url_string => "http://www.pixiv.net/member.php?id=8678371")
|
|
end
|
|
|
|
should "find the correct artist by looking up the profile url" do
|
|
assert_artist_found("ryuura", "http://www.pixiv.net/member_illust.php?mode=medium&illust_id=48788677")
|
|
end
|
|
|
|
should "find the correct artist for old image URLs" do
|
|
assert_artist_found("masao", "http://i2.pixiv.net/img04/img/syounen_no_uta/46170939.jpg")
|
|
assert_artist_found("bkub", "http://i1.pixiv.net/img01/img/bkubb/46239857_m.jpg")
|
|
end
|
|
|
|
should "find the correct artist for new image URLs" do
|
|
assert_artist_found("masao", "http://i2.pixiv.net/c/1200x1200/img-master/img/2014/09/25/00/57/24/46170939_p0_master1200.jpg")
|
|
assert_artist_found("masao", "http://i2.pixiv.net/img-original/img/2014/09/25/00/57/24/46170939_p0.jpg")
|
|
|
|
assert_artist_found("bkub", "http://i2.pixiv.net/c/1200x1200/img-master/img/2014/09/28/21/59/44/46239857_p0.jpg")
|
|
assert_artist_found("bkub", "http://i2.pixiv.net/img-original/img/2014/09/28/21/59/44/46239857_p0.jpg")
|
|
end
|
|
|
|
should "find the correct artist for page URLs" do
|
|
assert_artist_found("masao", "http://www.pixiv.net/member_illust.php?mode=medium&illust_id=46170939")
|
|
assert_artist_found("masao", "http://www.pixiv.net/member_illust.php?mode=big&illust_id=46170939")
|
|
assert_artist_found("masao", "http://www.pixiv.net/member_illust.php?mode=manga&illust_id=46170939")
|
|
assert_artist_found("masao", "http://www.pixiv.net/member_illust.php?mode=manga_big&illust_id=46170939&page=0")
|
|
assert_artist_found("masao", "http://www.pixiv.net/i/46170939")
|
|
|
|
assert_artist_found("bkub", "http://www.pixiv.net/member_illust.php?mode=medium&illust_id=46239857")
|
|
assert_artist_found("bkub", "http://www.pixiv.net/member_illust.php?mode=big&illust_id=46239857")
|
|
assert_artist_found("bkub", "http://www.pixiv.net/i/46239857")
|
|
end
|
|
|
|
should "find nothing for bad IDs" do
|
|
assert_artist_not_found("http://www.pixiv.net/member_illust.php?mode=medium&illust_id=32049358")
|
|
end
|
|
end
|
|
|
|
context "when finding nico seiga artists" do
|
|
setup do
|
|
FactoryBot.create(:artist, :name => "osamari", :url_string => "http://seiga.nicovideo.jp/user/illust/7017777")
|
|
FactoryBot.create(:artist, :name => "hakuro109", :url_string => "http://seiga.nicovideo.jp/user/illust/16265470")
|
|
end
|
|
|
|
should "find the artist by the profile" do
|
|
assert_artist_found("osamari", "http://seiga.nicovideo.jp/seiga/im4937663")
|
|
assert_artist_found("hakuro109", "http://lohas.nicoseiga.jp/priv/b9ea863e691f3a648dee5582fd6911c30dc8acab/1510092103/6424205")
|
|
end
|
|
|
|
should "return nothing for unknown nico seiga artists" do
|
|
assert_artist_not_found("http://seiga.nicovideo.jp/seiga/im6605221")
|
|
assert_artist_not_found("http://lohas.nicoseiga.jp/priv/fd195b3405b19874c825eb4d81c9196086562c6b/1509089019/6605221")
|
|
end
|
|
end
|
|
|
|
context "when finding twitter artists" do
|
|
setup do
|
|
skip "Twitter key is not set" unless Danbooru.config.twitter_api_key
|
|
FactoryBot.create(:artist, :name => "hammer_(sunset_beach)", :url_string => "http://twitter.com/hamaororon")
|
|
FactoryBot.create(:artist, :name => "haruyama_kazunori", :url_string => "https://twitter.com/kazuharoom")
|
|
end
|
|
|
|
should "find the correct artist for twitter.com sources" do
|
|
assert_artist_found("hammer_(sunset_beach)", "http://twitter.com/hamaororon/status/684338785744637952")
|
|
assert_artist_found("hammer_(sunset_beach)", "https://twitter.com/hamaororon/status/684338785744637952")
|
|
|
|
assert_artist_found("haruyama_kazunori", "http://twitter.com/kazuharoom/status/733355069966426113")
|
|
assert_artist_found("haruyama_kazunori", "https://twitter.com/kazuharoom/status/733355069966426113")
|
|
end
|
|
|
|
should "find the correct artist for mobile.twitter.com sources" do
|
|
assert_artist_found("hammer_(sunset_beach)", "http://mobile.twitter.com/hamaororon/status/684338785744637952")
|
|
assert_artist_found("hammer_(sunset_beach)", "https://mobile.twitter.com/hamaororon/status/684338785744637952")
|
|
|
|
assert_artist_found("haruyama_kazunori", "http://mobile.twitter.com/kazuharoom/status/733355069966426113")
|
|
assert_artist_found("haruyama_kazunori", "https://mobile.twitter.com/kazuharoom/status/733355069966426113")
|
|
end
|
|
|
|
should "return nothing for unknown twitter.com sources" do
|
|
assert_artist_not_found("http://twitter.com/bkub_comic/status/782880825700343808")
|
|
assert_artist_not_found("https://twitter.com/bkub_comic/status/782880825700343808")
|
|
end
|
|
|
|
should "return nothing for unknown mobile.twitter.com sources" do
|
|
assert_artist_not_found("http://mobile.twitter.com/bkub_comic/status/782880825700343808")
|
|
assert_artist_not_found("https://mobile.twitter.com/bkub_comic/status/782880825700343808")
|
|
end
|
|
end
|
|
|
|
context "when finding pawoo artists" do
|
|
setup do
|
|
skip "Pawoo keys not set" unless Danbooru.config.pawoo_client_id
|
|
FactoryBot.create(:artist, :name => "evazion", :url_string => "https://pawoo.net/@evazion")
|
|
FactoryBot.create(:artist, :name => "yasumo01", :url_string => "https://pawoo.net/web/accounts/28816")
|
|
end
|
|
|
|
should "find the artist" do
|
|
assert_artist_found("evazion", "https://pawoo.net/@evazion/19451018")
|
|
assert_artist_found("evazion", "https://pawoo.net/web/statuses/19451018")
|
|
end
|
|
|
|
should_eventually "find artists by account id" do
|
|
assert_artist_found("yasumo01", "https://pawoo.net/@yasumo01/222337")
|
|
assert_artist_found("yasumo01", "https://pawoo.net/web/statuses/222337")
|
|
end
|
|
|
|
should "return nothing for unknown pawoo sources" do
|
|
assert_artist_not_found("https://pawoo.net/@9ed00e924818/1202176")
|
|
assert_artist_not_found("https://pawoo.net/web/statuses/1202176")
|
|
end
|
|
end
|
|
|
|
context "when finding nijie artists" do
|
|
setup do
|
|
FactoryBot.create(:artist, :name => "evazion", :url_string => "http://nijie.info/members.php?id=236014")
|
|
FactoryBot.create(:artist, :name => "728995", :url_string => "http://nijie.info/members.php?id=728995")
|
|
end
|
|
|
|
should "find the artist" do
|
|
skip "Nijie credentials not configured" unless Sources::Strategies::Nijie.enabled?
|
|
assert_artist_found("evazion", "http://nijie.info/view.php?id=218944")
|
|
assert_artist_found("728995", "http://nijie.info/view.php?id=213043")
|
|
end
|
|
|
|
should "return nothing for unknown nijie artists" do
|
|
assert_artist_not_found("http://nijie.info/view.php?id=157953")
|
|
end
|
|
end
|
|
|
|
context "when finding tumblr artists" do
|
|
setup do
|
|
FactoryBot.create(:artist, :name => "ilya_kuvshinov", :url_string => "http://kuvshinov-ilya.tumblr.com")
|
|
FactoryBot.create(:artist, :name => "j.k.", :url_string => "https://jdotkdot5.tumblr.com")
|
|
end
|
|
|
|
should "find the artist" do
|
|
assert_artist_found("ilya_kuvshinov", "http://kuvshinov-ilya.tumblr.com/post/168641755845")
|
|
assert_artist_found("j.k.", "https://jdotkdot5.tumblr.com/post/168276640697")
|
|
end
|
|
|
|
should "return nothing for unknown tumblr artists" do
|
|
assert_artist_not_found("https://peptosis.tumblr.com/post/168162082005")
|
|
end
|
|
end
|
|
|
|
context "when finding fc2.com artists" do
|
|
setup do
|
|
create(:artist, name: "awa", url_string: "http://abk00.blog.fc2.com")
|
|
end
|
|
|
|
should "find the artist" do
|
|
assert_artist_found("awa", "http://blog71.fc2.com/a/abk00/file/20080220194219.jpg")
|
|
end
|
|
|
|
should "return nothing for an unknown artist" do
|
|
assert_artist_not_found("http://blog71.fc2.com/a/nobody/file/20080220194219.jpg")
|
|
end
|
|
end
|
|
|
|
context "the #normalize_other_names method" do
|
|
subject { build(:artist) }
|
|
|
|
should normalize_attribute(:other_names).from([" foo"]).to(["foo"])
|
|
should normalize_attribute(:other_names).from(["foo "]).to(["foo"])
|
|
should normalize_attribute(:other_names).from(["___foo"]).to(["___foo"])
|
|
should normalize_attribute(:other_names).from(["foo___"]).to(["foo___"])
|
|
should normalize_attribute(:other_names).from(["foo\n"]).to(["foo"])
|
|
should normalize_attribute(:other_names).from(["foo bar"]).to(["foo_bar"])
|
|
should normalize_attribute(:other_names).from(["foo bar"]).to(["foo_bar"])
|
|
should normalize_attribute(:other_names).from(["foo___bar"]).to(["foo___bar"])
|
|
should normalize_attribute(:other_names).from([" _Foo Bar_ "]).to(["_Foo_Bar_"])
|
|
should normalize_attribute(:other_names).from(["foo 1", "bar 2"]).to(["foo_1", "bar_2"])
|
|
should normalize_attribute(:other_names).from(["foo", nil, "", " ", "bar"]).to(["foo", "bar"])
|
|
should normalize_attribute(:other_names).from([nil, "", " "]).to([])
|
|
should normalize_attribute(:other_names).from(["pokémon".unicode_normalize(:nfd)]).to(["pokémon".unicode_normalize(:nfkc)])
|
|
should normalize_attribute(:other_names).from(["foo", "foo"]).to(["foo"])
|
|
should normalize_attribute(:other_names).from(["🏳️🌈"]).to(["🏳️🌈"])
|
|
|
|
should normalize_attribute(:other_names).from("foo foo").to(["foo"])
|
|
should normalize_attribute(:other_names).from("foo bar").to(["foo", "bar"])
|
|
should normalize_attribute(:other_names).from("_foo_ Bar").to(["_foo_", "Bar"])
|
|
end
|
|
|
|
context "group name" do
|
|
should normalize_attribute(:group_name).from(" ").to("")
|
|
should normalize_attribute(:group_name).from(" foo").to("foo")
|
|
should normalize_attribute(:group_name).from("foo ").to("foo")
|
|
should normalize_attribute(:group_name).from("___foo").to("___foo")
|
|
should normalize_attribute(:group_name).from("foo___").to("foo___")
|
|
should normalize_attribute(:group_name).from("foo\n").to("foo")
|
|
should normalize_attribute(:group_name).from("foo bar").to("foo_bar")
|
|
should normalize_attribute(:group_name).from("foo bar").to("foo_bar")
|
|
should normalize_attribute(:group_name).from("foo___bar").to("foo___bar")
|
|
should normalize_attribute(:group_name).from(" _Foo Bar_ ").to("_Foo_Bar_")
|
|
should normalize_attribute(:group_name).from("_foo_ Bar").to("_foo__Bar")
|
|
should normalize_attribute(:group_name).from("pokémon".unicode_normalize(:nfd)).to("pokémon".unicode_normalize(:nfkc))
|
|
should normalize_attribute(:group_name).from("🏳️🌈").to("🏳️🌈")
|
|
end
|
|
|
|
should "search on its name should return results" do
|
|
artist = FactoryBot.create(:artist, :name => "artist")
|
|
|
|
assert_not_nil(Artist.search(:name => "artist").first)
|
|
assert_not_nil(Artist.search(:name_like => "artist").first)
|
|
assert_not_nil(Artist.search(:any_name_matches => "artist").first)
|
|
assert_not_nil(Artist.search(:any_name_matches => "/art/").first)
|
|
end
|
|
|
|
should "search on other names should return matches" do
|
|
artist = FactoryBot.create(:artist, :name => "artist", :other_names_string => "aaa ccc_ddd")
|
|
|
|
assert_nil(Artist.search(any_other_name_like: "*artist*").first)
|
|
assert_not_nil(Artist.search(any_other_name_like: "*aaa*").first)
|
|
assert_not_nil(Artist.search(any_other_name_like: "*ccc_ddd*").first)
|
|
assert_not_nil(Artist.search(name: "artist").first)
|
|
assert_not_nil(Artist.search(:any_name_matches => "aaa").first)
|
|
assert_not_nil(Artist.search(:any_name_matches => "/a/").first)
|
|
end
|
|
|
|
should "search on group name and return matches" do
|
|
cat_or_fish = FactoryBot.create(:artist, :name => "cat_or_fish")
|
|
yuu = FactoryBot.create(:artist, :name => "yuu", :group_name => "cat_or_fish")
|
|
|
|
assert_not_nil(Artist.search(:group_name => "cat_or_fish").first)
|
|
assert_not_nil(Artist.search(:any_name_matches => "cat_or_fish").first)
|
|
assert_not_nil(Artist.search(:any_name_matches => "/cat/").first)
|
|
end
|
|
|
|
should "search on url and return matches" do
|
|
bkub = FactoryBot.create(:artist, name: "bkub", url_string: "http://bkub.com")
|
|
|
|
assert_equal([bkub.id], Artist.search(url_matches: "bkub").map(&:id))
|
|
assert_equal([bkub.id], Artist.search(url_matches: "*bkub*").map(&:id))
|
|
assert_equal([bkub.id], Artist.search(url_matches: "/rifyu|bkub/").map(&:id))
|
|
assert_equal([bkub.id], Artist.search(url_matches: "http://bkub.com/test.jpg").map(&:id))
|
|
end
|
|
|
|
should "search on has_tag and return matches" do
|
|
bkub = FactoryBot.create(:artist, name: "bkub")
|
|
none = FactoryBot.create(:artist, name: "none")
|
|
post = FactoryBot.create(:post, tag_string: "bkub")
|
|
|
|
assert_equal(bkub.id, Artist.search(has_tag: "true").first.id)
|
|
assert_equal(none.id, Artist.search(has_tag: "false").first.id)
|
|
end
|
|
|
|
should "revert to prior versions" do
|
|
user = FactoryBot.create(:user)
|
|
reverter = FactoryBot.create(:user)
|
|
artist = nil
|
|
assert_difference("ArtistVersion.count") do
|
|
artist = FactoryBot.create(:artist, :other_names => "yyy")
|
|
end
|
|
|
|
assert_difference("ArtistVersion.count") do
|
|
artist.other_names = "xxx"
|
|
travel(1.day) do
|
|
artist.save
|
|
end
|
|
end
|
|
|
|
first_version = ArtistVersion.first
|
|
assert_equal(%w[yyy], first_version.other_names)
|
|
artist.revert_to!(first_version)
|
|
artist.reload
|
|
assert_equal(%w[yyy], artist.other_names)
|
|
end
|
|
|
|
context "when creating" do
|
|
should "create a new artist tag if one does not already exist" do
|
|
FactoryBot.create(:artist, name: "bkub")
|
|
assert(Tag.exists?(name: "bkub", category: Tag.categories.artist))
|
|
end
|
|
|
|
should "change the tag to an artist tag if it was an empty gentag" do
|
|
tag = FactoryBot.create(:tag, name: "abc", category: Tag.categories.general, post_count: 0)
|
|
artist = FactoryBot.create(:artist, name: "abc")
|
|
|
|
assert_equal(Tag.categories.artist, tag.reload.category)
|
|
end
|
|
|
|
should "not allow creating artist entries for non-artist tags" do
|
|
tag = FactoryBot.create(:tag, name: "touhou", category: Tag.categories.copyright)
|
|
artist = FactoryBot.build(:artist, name: "touhou")
|
|
|
|
assert(artist.invalid?)
|
|
assert_match(/'touhou' is a copyright tag/, artist.errors.full_messages.join)
|
|
end
|
|
|
|
should "not allow creating artist entries for aliased tags" do
|
|
tag_alias = create(:tag_alias, antecedent_name: "foo", consequent_name: "bar")
|
|
artist = build(:artist, name: "foo")
|
|
|
|
assert_equal(true, artist.invalid?)
|
|
assert_match(/'foo' is aliased to 'bar'/, artist.errors.full_messages.join)
|
|
end
|
|
end
|
|
|
|
context "when renaming" do
|
|
should "change the new tag to an artist tag if it was a gentag" do
|
|
tag = FactoryBot.create(:tag, name: "def", category: Tag.categories.general, post_count: 0)
|
|
artist = FactoryBot.create(:artist, name: "abc")
|
|
artist.update(name: "def")
|
|
|
|
assert_equal(Tag.categories.artist, tag.reload.category)
|
|
end
|
|
end
|
|
|
|
context "when saving" do
|
|
setup do
|
|
@artist = FactoryBot.create(:artist, url_string: "http://foo.com")
|
|
@artist.stubs(:merge_version?).returns(false)
|
|
end
|
|
|
|
should "create a new version when an url is added" do
|
|
assert_difference("ArtistVersion.count") do
|
|
@artist.update(:url_string => "http://foo.com http://bar.com")
|
|
assert_equal(%w[http://bar.com http://foo.com], @artist.versions.last.urls)
|
|
end
|
|
end
|
|
|
|
should "create a new version when an url is removed" do
|
|
assert_difference("ArtistVersion.count") do
|
|
@artist.update(:url_string => "")
|
|
assert_equal(%w[], @artist.versions.last.urls)
|
|
end
|
|
end
|
|
|
|
should "create a new version when an url is marked inactive" do
|
|
assert_difference("ArtistVersion.count") do
|
|
@artist.update(:url_string => "-http://foo.com")
|
|
assert_equal(%w[-http://foo.com], @artist.versions.last.urls)
|
|
end
|
|
end
|
|
|
|
should "not create a new version when nothing has changed" do
|
|
assert_no_difference("ArtistVersion.count") do
|
|
@artist.save
|
|
assert_equal(%w[http://foo.com], @artist.versions.last.urls)
|
|
end
|
|
end
|
|
|
|
should "not save invalid urls" do
|
|
assert_no_difference("ArtistVersion.count") do
|
|
@artist.update(url_string: "http://foo.com :42")
|
|
|
|
assert_equal(%w[http://foo.com], @artist.versions.last.urls)
|
|
end
|
|
end
|
|
end
|
|
|
|
context "that is deleted" do
|
|
setup do
|
|
@artist = create(:artist, url_string: "https://google.com")
|
|
@artist.update_attribute(:is_deleted, true)
|
|
@artist.reload
|
|
end
|
|
|
|
should "preserve the url string" do
|
|
assert_equal(1, @artist.urls.count)
|
|
end
|
|
end
|
|
|
|
context "#new_with_defaults" do
|
|
should "fetch the defaults from the given source" do
|
|
source = "https://i.pximg.net/img-original/img/2018/01/28/23/56/50/67014762_p0.jpg"
|
|
artist = Artist.new_with_defaults(source: source)
|
|
|
|
assert_equal("niceandcool", artist.name)
|
|
assert_equal("Nice_and_Cool niceandcool", artist.other_names_string)
|
|
assert_includes(artist.urls.map(&:url), "https://www.pixiv.net/users/906442")
|
|
assert_includes(artist.urls.map(&:url), "https://www.pixiv.net/stacc/niceandcool")
|
|
end
|
|
|
|
should "fetch the defaults from the given tag" do
|
|
source = "https://i.pximg.net/img-original/img/2018/01/28/23/56/50/67014762_p0.jpg"
|
|
FactoryBot.create(:post, source: source, tag_string: "test_artist")
|
|
artist = Artist.new_with_defaults(name: "test_artist")
|
|
|
|
assert_equal("test_artist", artist.name)
|
|
assert_equal("Nice_and_Cool niceandcool", artist.other_names_string)
|
|
assert_includes(artist.urls.map(&:url), "https://www.pixiv.net/users/906442")
|
|
assert_includes(artist.urls.map(&:url), "https://www.pixiv.net/stacc/niceandcool")
|
|
end
|
|
end
|
|
end
|
|
end
|