account_spec.rb 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826
  1. require 'rails_helper'
  2. RSpec.describe Account, type: :model do
  3. context do
  4. let(:bob) { Fabricate(:account, username: 'bob') }
  5. subject { Fabricate(:account) }
  6. describe '#follow!' do
  7. it 'creates a follow' do
  8. follow = subject.follow!(bob)
  9. expect(follow).to be_instance_of Follow
  10. expect(follow.account).to eq subject
  11. expect(follow.target_account).to eq bob
  12. end
  13. end
  14. describe '#unfollow!' do
  15. before do
  16. subject.follow!(bob)
  17. end
  18. it 'destroys a follow' do
  19. unfollow = subject.unfollow!(bob)
  20. expect(unfollow).to be_instance_of Follow
  21. expect(unfollow.account).to eq subject
  22. expect(unfollow.target_account).to eq bob
  23. expect(unfollow.destroyed?).to be true
  24. end
  25. end
  26. describe '#following?' do
  27. it 'returns true when the target is followed' do
  28. subject.follow!(bob)
  29. expect(subject.following?(bob)).to be true
  30. end
  31. it 'returns false if the target is not followed' do
  32. expect(subject.following?(bob)).to be false
  33. end
  34. end
  35. end
  36. describe '#local?' do
  37. it 'returns true when the account is local' do
  38. account = Fabricate(:account, domain: nil)
  39. expect(account.local?).to be true
  40. end
  41. it 'returns false when the account is on a different domain' do
  42. account = Fabricate(:account, domain: 'foreign.tld')
  43. expect(account.local?).to be false
  44. end
  45. end
  46. describe 'Local domain user methods' do
  47. around do |example|
  48. before = Rails.configuration.x.local_domain
  49. example.run
  50. Rails.configuration.x.local_domain = before
  51. end
  52. subject { Fabricate(:account, domain: nil, username: 'alice') }
  53. describe '#to_webfinger_s' do
  54. it 'returns a webfinger string for the account' do
  55. Rails.configuration.x.local_domain = 'example.com'
  56. expect(subject.to_webfinger_s).to eq 'acct:alice@example.com'
  57. end
  58. end
  59. describe '#local_username_and_domain' do
  60. it 'returns the username and local domain for the account' do
  61. Rails.configuration.x.local_domain = 'example.com'
  62. expect(subject.local_username_and_domain).to eq 'alice@example.com'
  63. end
  64. end
  65. end
  66. describe '#acct' do
  67. it 'returns username for local users' do
  68. account = Fabricate(:account, domain: nil, username: 'alice')
  69. expect(account.acct).to eql 'alice'
  70. end
  71. it 'returns username@domain for foreign users' do
  72. account = Fabricate(:account, domain: 'foreign.tld', username: 'alice')
  73. expect(account.acct).to eql 'alice@foreign.tld'
  74. end
  75. end
  76. describe '#save_with_optional_media!' do
  77. before do
  78. stub_request(:get, 'https://remote.test/valid_avatar').to_return(request_fixture('avatar.txt'))
  79. stub_request(:get, 'https://remote.test/invalid_avatar').to_return(request_fixture('feed.txt'))
  80. end
  81. let(:account) do
  82. Fabricate(:account,
  83. avatar_remote_url: 'https://remote.test/valid_avatar',
  84. header_remote_url: 'https://remote.test/valid_avatar')
  85. end
  86. let!(:expectation) { account.dup }
  87. context 'with valid properties' do
  88. before do
  89. account.save_with_optional_media!
  90. end
  91. it 'unchanges avatar, header, avatar_remote_url, and header_remote_url' do
  92. expect(account.avatar_remote_url).to eq expectation.avatar_remote_url
  93. expect(account.header_remote_url).to eq expectation.header_remote_url
  94. expect(account.avatar_file_name).to eq expectation.avatar_file_name
  95. expect(account.header_file_name).to eq expectation.header_file_name
  96. end
  97. end
  98. context 'with invalid properties' do
  99. before do
  100. account.avatar_remote_url = 'https://remote.test/invalid_avatar'
  101. account.save_with_optional_media!
  102. end
  103. it 'sets default avatar, header, avatar_remote_url, and header_remote_url' do
  104. expect(account.avatar_remote_url).to eq 'https://remote.test/invalid_avatar'
  105. expect(account.header_remote_url).to eq expectation.header_remote_url
  106. expect(account.avatar_file_name).to eq nil
  107. expect(account.header_file_name).to eq nil
  108. end
  109. end
  110. end
  111. describe '#subscribed?' do
  112. it 'returns false when no subscription expiration information is present' do
  113. account = Fabricate(:account, subscription_expires_at: nil)
  114. expect(account.subscribed?).to be false
  115. end
  116. it 'returns true when subscription expiration has been set' do
  117. account = Fabricate(:account, subscription_expires_at: 30.days.from_now)
  118. expect(account.subscribed?).to be true
  119. end
  120. end
  121. describe '#possibly_stale?' do
  122. let(:account) { Fabricate(:account, last_webfingered_at: last_webfingered_at) }
  123. context 'last_webfingered_at is nil' do
  124. let(:last_webfingered_at) { nil }
  125. it 'returns true' do
  126. expect(account.possibly_stale?).to be true
  127. end
  128. end
  129. context 'last_webfingered_at is more than 24 hours before' do
  130. let(:last_webfingered_at) { 25.hours.ago }
  131. it 'returns true' do
  132. expect(account.possibly_stale?).to be true
  133. end
  134. end
  135. context 'last_webfingered_at is less than 24 hours before' do
  136. let(:last_webfingered_at) { 23.hours.ago }
  137. it 'returns false' do
  138. expect(account.possibly_stale?).to be false
  139. end
  140. end
  141. end
  142. describe '#refresh!' do
  143. let(:account) { Fabricate(:account, domain: domain) }
  144. let(:acct) { account.acct }
  145. context 'domain is nil' do
  146. let(:domain) { nil }
  147. it 'returns nil' do
  148. expect(account.refresh!).to be_nil
  149. end
  150. it 'calls not ResolveAccountService#call' do
  151. expect_any_instance_of(ResolveAccountService).not_to receive(:call).with(acct)
  152. account.refresh!
  153. end
  154. end
  155. context 'domain is present' do
  156. let(:domain) { 'example.com' }
  157. it 'calls ResolveAccountService#call' do
  158. expect_any_instance_of(ResolveAccountService).to receive(:call).with(acct).once
  159. account.refresh!
  160. end
  161. end
  162. end
  163. describe '#to_param' do
  164. it 'returns username' do
  165. account = Fabricate(:account, username: 'alice')
  166. expect(account.to_param).to eq 'alice'
  167. end
  168. end
  169. describe '#keypair' do
  170. it 'returns an RSA key pair' do
  171. account = Fabricate(:account)
  172. expect(account.keypair).to be_instance_of OpenSSL::PKey::RSA
  173. end
  174. end
  175. describe '#subscription' do
  176. it 'returns an OStatus subscription' do
  177. account = Fabricate(:account)
  178. expect(account.subscription('')).to be_instance_of OStatus2::Subscription
  179. end
  180. end
  181. describe '#object_type' do
  182. it 'is always a person' do
  183. account = Fabricate(:account)
  184. expect(account.object_type).to be :person
  185. end
  186. end
  187. describe '#favourited?' do
  188. let(:original_status) do
  189. author = Fabricate(:account, username: 'original')
  190. Fabricate(:status, account: author)
  191. end
  192. subject { Fabricate(:account) }
  193. context 'when the status is a reblog of another status' do
  194. let(:original_reblog) do
  195. author = Fabricate(:account, username: 'original_reblogger')
  196. Fabricate(:status, reblog: original_status, account: author)
  197. end
  198. it 'is is true when this account has favourited it' do
  199. Fabricate(:favourite, status: original_reblog, account: subject)
  200. expect(subject.favourited?(original_status)).to eq true
  201. end
  202. it 'is false when this account has not favourited it' do
  203. expect(subject.favourited?(original_status)).to eq false
  204. end
  205. end
  206. context 'when the status is an original status' do
  207. it 'is is true when this account has favourited it' do
  208. Fabricate(:favourite, status: original_status, account: subject)
  209. expect(subject.favourited?(original_status)).to eq true
  210. end
  211. it 'is false when this account has not favourited it' do
  212. expect(subject.favourited?(original_status)).to eq false
  213. end
  214. end
  215. end
  216. describe '#reblogged?' do
  217. let(:original_status) do
  218. author = Fabricate(:account, username: 'original')
  219. Fabricate(:status, account: author)
  220. end
  221. subject { Fabricate(:account) }
  222. context 'when the status is a reblog of another status' do
  223. let(:original_reblog) do
  224. author = Fabricate(:account, username: 'original_reblogger')
  225. Fabricate(:status, reblog: original_status, account: author)
  226. end
  227. it 'is true when this account has reblogged it' do
  228. Fabricate(:status, reblog: original_reblog, account: subject)
  229. expect(subject.reblogged?(original_reblog)).to eq true
  230. end
  231. it 'is false when this account has not reblogged it' do
  232. expect(subject.reblogged?(original_reblog)).to eq false
  233. end
  234. end
  235. context 'when the status is an original status' do
  236. it 'is true when this account has reblogged it' do
  237. Fabricate(:status, reblog: original_status, account: subject)
  238. expect(subject.reblogged?(original_status)).to eq true
  239. end
  240. it 'is false when this account has not reblogged it' do
  241. expect(subject.reblogged?(original_status)).to eq false
  242. end
  243. end
  244. end
  245. describe '#excluded_from_timeline_account_ids' do
  246. it 'includes account ids of blockings, blocked_bys and mutes' do
  247. account = Fabricate(:account)
  248. block = Fabricate(:block, account: account)
  249. mute = Fabricate(:mute, account: account)
  250. block_by = Fabricate(:block, target_account: account)
  251. results = account.excluded_from_timeline_account_ids
  252. expect(results.size).to eq 3
  253. expect(results).to include(block.target_account.id)
  254. expect(results).to include(mute.target_account.id)
  255. expect(results).to include(block_by.account.id)
  256. end
  257. end
  258. describe '#excluded_from_timeline_domains' do
  259. it 'returns the domains blocked by the account' do
  260. account = Fabricate(:account)
  261. account.block_domain!('domain')
  262. expect(account.excluded_from_timeline_domains).to match_array ['domain']
  263. end
  264. end
  265. describe '.search_for' do
  266. before do
  267. _missing = Fabricate(
  268. :account,
  269. display_name: "Missing",
  270. username: "missing",
  271. domain: "missing.com"
  272. )
  273. end
  274. it 'accepts ?, \, : and space as delimiter' do
  275. match = Fabricate(
  276. :account,
  277. display_name: 'A & l & i & c & e',
  278. username: 'username',
  279. domain: 'example.com'
  280. )
  281. results = Account.search_for('A?l\i:c e')
  282. expect(results).to eq [match]
  283. end
  284. it 'finds accounts with matching display_name' do
  285. match = Fabricate(
  286. :account,
  287. display_name: "Display Name",
  288. username: "username",
  289. domain: "example.com"
  290. )
  291. results = Account.search_for("display")
  292. expect(results).to eq [match]
  293. end
  294. it 'finds accounts with matching username' do
  295. match = Fabricate(
  296. :account,
  297. display_name: "Display Name",
  298. username: "username",
  299. domain: "example.com"
  300. )
  301. results = Account.search_for("username")
  302. expect(results).to eq [match]
  303. end
  304. it 'finds accounts with matching domain' do
  305. match = Fabricate(
  306. :account,
  307. display_name: "Display Name",
  308. username: "username",
  309. domain: "example.com"
  310. )
  311. results = Account.search_for("example")
  312. expect(results).to eq [match]
  313. end
  314. it 'limits by 10 by default' do
  315. 11.times.each { Fabricate(:account, display_name: "Display Name") }
  316. results = Account.search_for("display")
  317. expect(results.size).to eq 10
  318. end
  319. it 'accepts arbitrary limits' do
  320. 2.times.each { Fabricate(:account, display_name: "Display Name") }
  321. results = Account.search_for("display", 1)
  322. expect(results.size).to eq 1
  323. end
  324. it 'ranks multiple matches higher' do
  325. matches = [
  326. { username: "username", display_name: "username" },
  327. { display_name: "Display Name", username: "username", domain: "example.com" },
  328. ].map(&method(:Fabricate).curry(2).call(:account))
  329. results = Account.search_for("username")
  330. expect(results).to eq matches
  331. end
  332. end
  333. describe '.advanced_search_for' do
  334. it 'accepts ?, \, : and space as delimiter' do
  335. account = Fabricate(:account)
  336. match = Fabricate(
  337. :account,
  338. display_name: 'A & l & i & c & e',
  339. username: 'username',
  340. domain: 'example.com'
  341. )
  342. results = Account.advanced_search_for('A?l\i:c e', account)
  343. expect(results).to eq [match]
  344. end
  345. it 'limits by 10 by default' do
  346. 11.times { Fabricate(:account, display_name: "Display Name") }
  347. results = Account.search_for("display")
  348. expect(results.size).to eq 10
  349. end
  350. it 'accepts arbitrary limits' do
  351. 2.times { Fabricate(:account, display_name: "Display Name") }
  352. results = Account.search_for("display", 1)
  353. expect(results.size).to eq 1
  354. end
  355. it 'ranks followed accounts higher' do
  356. account = Fabricate(:account)
  357. match = Fabricate(:account, username: "Matching")
  358. followed_match = Fabricate(:account, username: "Matcher")
  359. Fabricate(:follow, account: account, target_account: followed_match)
  360. results = Account.advanced_search_for("match", account)
  361. expect(results).to eq [followed_match, match]
  362. expect(results.first.rank).to be > results.last.rank
  363. end
  364. end
  365. describe '.domains' do
  366. it 'returns domains' do
  367. Fabricate(:account, domain: 'domain')
  368. expect(Account.remote.domains).to match_array(['domain'])
  369. end
  370. end
  371. describe '#statuses_count' do
  372. subject { Fabricate(:account) }
  373. it 'counts statuses' do
  374. Fabricate(:status, account: subject)
  375. Fabricate(:status, account: subject)
  376. expect(subject.statuses_count).to eq 2
  377. end
  378. it 'does not count direct statuses' do
  379. Fabricate(:status, account: subject, visibility: :direct)
  380. expect(subject.statuses_count).to eq 0
  381. end
  382. it 'is decremented when status is removed' do
  383. status = Fabricate(:status, account: subject)
  384. expect(subject.statuses_count).to eq 1
  385. status.destroy
  386. expect(subject.statuses_count).to eq 0
  387. end
  388. it 'is decremented when status is removed when account is not preloaded' do
  389. status = Fabricate(:status, account: subject)
  390. expect(subject.reload.statuses_count).to eq 1
  391. clean_status = Status.find(status.id)
  392. expect(clean_status.association(:account).loaded?).to be false
  393. clean_status.destroy
  394. expect(subject.reload.statuses_count).to eq 0
  395. end
  396. end
  397. describe '.following_map' do
  398. it 'returns an hash' do
  399. expect(Account.following_map([], 1)).to be_a Hash
  400. end
  401. end
  402. describe '.followed_by_map' do
  403. it 'returns an hash' do
  404. expect(Account.followed_by_map([], 1)).to be_a Hash
  405. end
  406. end
  407. describe '.blocking_map' do
  408. it 'returns an hash' do
  409. expect(Account.blocking_map([], 1)).to be_a Hash
  410. end
  411. end
  412. describe '.requested_map' do
  413. it 'returns an hash' do
  414. expect(Account.requested_map([], 1)).to be_a Hash
  415. end
  416. end
  417. describe 'MENTION_RE' do
  418. subject { Account::MENTION_RE }
  419. it 'matches usernames in the middle of a sentence' do
  420. expect(subject.match('Hello to @alice from me')[1]).to eq 'alice'
  421. end
  422. it 'matches usernames in the beginning of status' do
  423. expect(subject.match('@alice Hey how are you?')[1]).to eq 'alice'
  424. end
  425. it 'matches full usernames' do
  426. expect(subject.match('@alice@example.com')[1]).to eq 'alice@example.com'
  427. end
  428. it 'matches full usernames with a dot at the end' do
  429. expect(subject.match('Hello @alice@example.com.')[1]).to eq 'alice@example.com'
  430. end
  431. it 'matches dot-prepended usernames' do
  432. expect(subject.match('.@alice I want everybody to see this')[1]).to eq 'alice'
  433. end
  434. it 'does not match e-mails' do
  435. expect(subject.match('Drop me an e-mail at alice@example.com')).to be_nil
  436. end
  437. it 'does not match URLs' do
  438. expect(subject.match('Check this out https://medium.com/@alice/some-article#.abcdef123')).to be_nil
  439. end
  440. xit 'does not match URL querystring' do
  441. expect(subject.match('https://example.com/?x=@alice')).to be_nil
  442. end
  443. end
  444. describe 'validations' do
  445. it 'has a valid fabricator' do
  446. account = Fabricate.build(:account)
  447. account.valid?
  448. expect(account).to be_valid
  449. end
  450. it 'is invalid without a username' do
  451. account = Fabricate.build(:account, username: nil)
  452. account.valid?
  453. expect(account).to model_have_error_on_field(:username)
  454. end
  455. it 'squishes the username before validation' do
  456. account = Fabricate(:account, domain: nil, username: " \u3000bob \t \u00a0 \n ")
  457. expect(account.username).to eq 'bob'
  458. end
  459. context 'when is local' do
  460. it 'is invalid if the username is not unique in case-insensitive comparison among local accounts' do
  461. account_1 = Fabricate(:account, username: 'the_doctor')
  462. account_2 = Fabricate.build(:account, username: 'the_Doctor')
  463. account_2.valid?
  464. expect(account_2).to model_have_error_on_field(:username)
  465. end
  466. it 'is invalid if the username is reserved' do
  467. account = Fabricate.build(:account, username: 'support')
  468. account.valid?
  469. expect(account).to model_have_error_on_field(:username)
  470. end
  471. it 'is valid when username is reserved but record has already been created' do
  472. account = Fabricate.build(:account, username: 'support')
  473. account.save(validate: false)
  474. expect(account.valid?).to be true
  475. end
  476. it 'is valid if we are creating an instance actor account with a period' do
  477. account = Fabricate.build(:account, id: -99, actor_type: 'Application', locked: true, username: 'example.com')
  478. expect(account.valid?).to be true
  479. end
  480. it 'is valid if we are creating a possibly-conflicting instance actor account' do
  481. account_1 = Fabricate(:account, username: 'examplecom')
  482. account_2 = Fabricate.build(:account, id: -99, actor_type: 'Application', locked: true, username: 'example.com')
  483. expect(account_2.valid?).to be true
  484. end
  485. it 'is invalid if the username doesn\'t only contains letters, numbers and underscores' do
  486. account = Fabricate.build(:account, username: 'the-doctor')
  487. account.valid?
  488. expect(account).to model_have_error_on_field(:username)
  489. end
  490. it 'is invalid if the username contains a period' do
  491. account = Fabricate.build(:account, username: 'the.doctor')
  492. account.valid?
  493. expect(account).to model_have_error_on_field(:username)
  494. end
  495. it 'is invalid if the username is longer then 30 characters' do
  496. account = Fabricate.build(:account, username: Faker::Lorem.characters(number: 31))
  497. account.valid?
  498. expect(account).to model_have_error_on_field(:username)
  499. end
  500. it 'is invalid if the display name is longer than 30 characters' do
  501. account = Fabricate.build(:account, display_name: Faker::Lorem.characters(number: 31))
  502. account.valid?
  503. expect(account).to model_have_error_on_field(:display_name)
  504. end
  505. it 'is invalid if the note is longer than 500 characters' do
  506. account = Fabricate.build(:account, note: Faker::Lorem.characters(number: 501))
  507. account.valid?
  508. expect(account).to model_have_error_on_field(:note)
  509. end
  510. end
  511. context 'when is remote' do
  512. it 'is invalid if the username is not unique in case-sensitive comparison among accounts in the same normalized domain' do
  513. Fabricate(:account, domain: 'にゃん', username: 'username')
  514. account = Fabricate.build(:account, domain: 'xn--r9j5b5b', username: 'username')
  515. account.valid?
  516. expect(account).to model_have_error_on_field(:username)
  517. end
  518. it 'is valid even if the username is unique only in case-sensitive comparison among accounts in the same normalized domain' do
  519. Fabricate(:account, domain: 'にゃん', username: 'username')
  520. account = Fabricate.build(:account, domain: 'xn--r9j5b5b', username: 'Username')
  521. account.valid?
  522. expect(account).not_to model_have_error_on_field(:username)
  523. end
  524. it 'is valid even if the username contains hyphens' do
  525. account = Fabricate.build(:account, domain: 'domain', username: 'the-doctor')
  526. account.valid?
  527. expect(account).to_not model_have_error_on_field(:username)
  528. end
  529. it 'is invalid if the username doesn\'t only contains letters, numbers, underscores and hyphens' do
  530. account = Fabricate.build(:account, domain: 'domain', username: 'the doctor')
  531. account.valid?
  532. expect(account).to model_have_error_on_field(:username)
  533. end
  534. it 'is valid even if the username is longer then 30 characters' do
  535. account = Fabricate.build(:account, domain: 'domain', username: Faker::Lorem.characters(number: 31))
  536. account.valid?
  537. expect(account).not_to model_have_error_on_field(:username)
  538. end
  539. it 'is valid even if the display name is longer than 30 characters' do
  540. account = Fabricate.build(:account, domain: 'domain', display_name: Faker::Lorem.characters(number: 31))
  541. account.valid?
  542. expect(account).not_to model_have_error_on_field(:display_name)
  543. end
  544. it 'is valid even if the note is longer than 500 characters' do
  545. account = Fabricate.build(:account, domain: 'domain', note: Faker::Lorem.characters(number: 501))
  546. account.valid?
  547. expect(account).not_to model_have_error_on_field(:note)
  548. end
  549. end
  550. end
  551. describe 'scopes' do
  552. describe 'alphabetic' do
  553. it 'sorts by alphabetic order of domain and username' do
  554. matches = [
  555. { username: 'a', domain: 'a' },
  556. { username: 'b', domain: 'a' },
  557. { username: 'a', domain: 'b' },
  558. { username: 'b', domain: 'b' },
  559. ].map(&method(:Fabricate).curry(2).call(:account))
  560. expect(Account.where('id > 0').alphabetic).to eq matches
  561. end
  562. end
  563. describe 'matches_display_name' do
  564. it 'matches display name which starts with the given string' do
  565. match = Fabricate(:account, display_name: 'pattern and suffix')
  566. Fabricate(:account, display_name: 'prefix and pattern')
  567. expect(Account.matches_display_name('pattern')).to eq [match]
  568. end
  569. end
  570. describe 'matches_username' do
  571. it 'matches display name which starts with the given string' do
  572. match = Fabricate(:account, username: 'pattern_and_suffix')
  573. Fabricate(:account, username: 'prefix_and_pattern')
  574. expect(Account.matches_username('pattern')).to eq [match]
  575. end
  576. end
  577. describe 'by_domain_and_subdomains' do
  578. it 'returns exact domain matches' do
  579. account = Fabricate(:account, domain: 'example.com')
  580. expect(Account.by_domain_and_subdomains('example.com')).to eq [account]
  581. end
  582. it 'returns subdomains' do
  583. account = Fabricate(:account, domain: 'foo.example.com')
  584. expect(Account.by_domain_and_subdomains('example.com')).to eq [account]
  585. end
  586. it 'does not return partially matching domains' do
  587. account = Fabricate(:account, domain: 'grexample.com')
  588. expect(Account.by_domain_and_subdomains('example.com')).to_not eq [account]
  589. end
  590. end
  591. describe 'expiring' do
  592. it 'returns remote accounts with followers whose subscription expiration date is past or not given' do
  593. local = Fabricate(:account, domain: nil)
  594. matches = [
  595. { domain: 'remote', subscription_expires_at: '2000-01-01T00:00:00Z' },
  596. ].map(&method(:Fabricate).curry(2).call(:account))
  597. matches.each(&local.method(:follow!))
  598. Fabricate(:account, domain: 'remote', subscription_expires_at: nil)
  599. local.follow!(Fabricate(:account, domain: 'remote', subscription_expires_at: '2000-01-03T00:00:00Z'))
  600. local.follow!(Fabricate(:account, domain: nil, subscription_expires_at: nil))
  601. expect(Account.expiring('2000-01-02T00:00:00Z').recent).to eq matches.reverse
  602. end
  603. end
  604. describe 'remote' do
  605. it 'returns an array of accounts who have a domain' do
  606. account_1 = Fabricate(:account, domain: nil)
  607. account_2 = Fabricate(:account, domain: 'example.com')
  608. expect(Account.remote).to match_array([account_2])
  609. end
  610. end
  611. describe 'by_domain_accounts' do
  612. it 'returns accounts grouped by domain sorted by accounts' do
  613. 2.times { Fabricate(:account, domain: 'example.com') }
  614. Fabricate(:account, domain: 'example2.com')
  615. results = Account.where('id > 0').by_domain_accounts
  616. expect(results.length).to eq 2
  617. expect(results.first.domain).to eq 'example.com'
  618. expect(results.first.accounts_count).to eq 2
  619. expect(results.last.domain).to eq 'example2.com'
  620. expect(results.last.accounts_count).to eq 1
  621. end
  622. end
  623. describe 'local' do
  624. it 'returns an array of accounts who do not have a domain' do
  625. account_1 = Fabricate(:account, domain: nil)
  626. account_2 = Fabricate(:account, domain: 'example.com')
  627. expect(Account.where('id > 0').local).to match_array([account_1])
  628. end
  629. end
  630. describe 'partitioned' do
  631. it 'returns a relation of accounts partitioned by domain' do
  632. matches = ['a', 'b', 'a', 'b']
  633. matches.size.times.to_a.shuffle.each do |index|
  634. matches[index] = Fabricate(:account, domain: matches[index])
  635. end
  636. expect(Account.where('id > 0').partitioned).to match_array(matches)
  637. end
  638. end
  639. describe 'recent' do
  640. it 'returns a relation of accounts sorted by recent creation' do
  641. matches = 2.times.map { Fabricate(:account) }
  642. expect(Account.where('id > 0').recent).to match_array(matches)
  643. end
  644. end
  645. describe 'silenced' do
  646. it 'returns an array of accounts who are silenced' do
  647. account_1 = Fabricate(:account, silenced: true)
  648. account_2 = Fabricate(:account, silenced: false)
  649. expect(Account.silenced).to match_array([account_1])
  650. end
  651. end
  652. describe 'suspended' do
  653. it 'returns an array of accounts who are suspended' do
  654. account_1 = Fabricate(:account, suspended: true)
  655. account_2 = Fabricate(:account, suspended: false)
  656. expect(Account.suspended).to match_array([account_1])
  657. end
  658. end
  659. end
  660. context 'when is local' do
  661. # Test disabled because test environment omits autogenerating keys for performance
  662. xit 'generates keys' do
  663. account = Account.create!(domain: nil, username: Faker::Internet.user_name(separators: ['_']))
  664. expect(account.keypair.private?).to eq true
  665. end
  666. end
  667. context 'when is remote' do
  668. it 'does not generate keys' do
  669. key = OpenSSL::PKey::RSA.new(1024).public_key
  670. account = Account.create!(domain: 'remote', username: Faker::Internet.user_name(separators: ['_']), public_key: key.to_pem)
  671. expect(account.keypair.params).to eq key.params
  672. end
  673. it 'normalizes domain' do
  674. account = Account.create!(domain: 'にゃん', username: Faker::Internet.user_name(separators: ['_']))
  675. expect(account.domain).to eq 'xn--r9j5b5b'
  676. end
  677. end
  678. include_examples 'AccountAvatar', :account
  679. end