The Cybre.Space fork of Mastodon -- https://github.com/tootsuite/mastodon https://cybre.space
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

account_spec.rb 25KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792
  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 ''
  105. expect(account.header_remote_url).to eq ''
  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.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 invalid if the username doesn\'t only contains letters, numbers and underscores' do
  477. account = Fabricate.build(:account, username: 'the-doctor')
  478. account.valid?
  479. expect(account).to model_have_error_on_field(:username)
  480. end
  481. it 'is invalid if the username is longer then 30 characters' do
  482. account = Fabricate.build(:account, username: Faker::Lorem.characters(31))
  483. account.valid?
  484. expect(account).to model_have_error_on_field(:username)
  485. end
  486. it 'is invalid if the display name is longer than 30 characters' do
  487. account = Fabricate.build(:account, display_name: Faker::Lorem.characters(31))
  488. account.valid?
  489. expect(account).to model_have_error_on_field(:display_name)
  490. end
  491. it 'is invalid if the note is longer than 413 characters' do
  492. account = Fabricate.build(:account, note: Faker::Lorem.characters(414))
  493. account.valid?
  494. expect(account).to model_have_error_on_field(:note)
  495. end
  496. end
  497. context 'when is remote' do
  498. it 'is invalid if the username is not unique in case-sensitive comparison among accounts in the same normalized domain' do
  499. Fabricate(:account, domain: 'にゃん', username: 'username')
  500. account = Fabricate.build(:account, domain: 'xn--r9j5b5b', username: 'username')
  501. account.valid?
  502. expect(account).to model_have_error_on_field(:username)
  503. end
  504. it 'is valid even if the username is unique only in case-sensitive comparison among accounts in the same normalized domain' do
  505. Fabricate(:account, domain: 'にゃん', username: 'username')
  506. account = Fabricate.build(:account, domain: 'xn--r9j5b5b', username: 'Username')
  507. account.valid?
  508. expect(account).not_to model_have_error_on_field(:username)
  509. end
  510. it 'is valid even if the username contains hyphens' do
  511. account = Fabricate.build(:account, domain: 'domain', username: 'the-doctor')
  512. account.valid?
  513. expect(account).to_not model_have_error_on_field(:username)
  514. end
  515. it 'is invalid if the username doesn\'t only contains letters, numbers, underscores and hyphens' do
  516. account = Fabricate.build(:account, domain: 'domain', username: 'the doctor')
  517. account.valid?
  518. expect(account).to model_have_error_on_field(:username)
  519. end
  520. it 'is valid even if the username is longer then 30 characters' do
  521. account = Fabricate.build(:account, domain: 'domain', username: Faker::Lorem.characters(31))
  522. account.valid?
  523. expect(account).not_to model_have_error_on_field(:username)
  524. end
  525. it 'is valid even if the display name is longer than 30 characters' do
  526. account = Fabricate.build(:account, domain: 'domain', display_name: Faker::Lorem.characters(31))
  527. account.valid?
  528. expect(account).not_to model_have_error_on_field(:display_name)
  529. end
  530. it 'is valid even if the note is longer than 413 characters' do
  531. account = Fabricate.build(:account, domain: 'domain', note: Faker::Lorem.characters(414))
  532. account.valid?
  533. expect(account).not_to model_have_error_on_field(:note)
  534. end
  535. end
  536. end
  537. describe 'scopes' do
  538. describe 'alphabetic' do
  539. it 'sorts by alphabetic order of domain and username' do
  540. matches = [
  541. { username: 'a', domain: 'a' },
  542. { username: 'b', domain: 'a' },
  543. { username: 'a', domain: 'b' },
  544. { username: 'b', domain: 'b' },
  545. ].map(&method(:Fabricate).curry(2).call(:account))
  546. expect(Account.alphabetic).to eq matches
  547. end
  548. end
  549. describe 'matches_display_name' do
  550. it 'matches display name which starts with the given string' do
  551. match = Fabricate(:account, display_name: 'pattern and suffix')
  552. Fabricate(:account, display_name: 'prefix and pattern')
  553. expect(Account.matches_display_name('pattern')).to eq [match]
  554. end
  555. end
  556. describe 'matches_username' do
  557. it 'matches display name which starts with the given string' do
  558. match = Fabricate(:account, username: 'pattern_and_suffix')
  559. Fabricate(:account, username: 'prefix_and_pattern')
  560. expect(Account.matches_username('pattern')).to eq [match]
  561. end
  562. end
  563. describe 'expiring' do
  564. it 'returns remote accounts with followers whose subscription expiration date is past or not given' do
  565. local = Fabricate(:account, domain: nil)
  566. matches = [
  567. { domain: 'remote', subscription_expires_at: '2000-01-01T00:00:00Z' },
  568. ].map(&method(:Fabricate).curry(2).call(:account))
  569. matches.each(&local.method(:follow!))
  570. Fabricate(:account, domain: 'remote', subscription_expires_at: nil)
  571. local.follow!(Fabricate(:account, domain: 'remote', subscription_expires_at: '2000-01-03T00:00:00Z'))
  572. local.follow!(Fabricate(:account, domain: nil, subscription_expires_at: nil))
  573. expect(Account.expiring('2000-01-02T00:00:00Z').recent).to eq matches.reverse
  574. end
  575. end
  576. describe 'remote' do
  577. it 'returns an array of accounts who have a domain' do
  578. account_1 = Fabricate(:account, domain: nil)
  579. account_2 = Fabricate(:account, domain: 'example.com')
  580. expect(Account.remote).to match_array([account_2])
  581. end
  582. end
  583. describe 'by_domain_accounts' do
  584. it 'returns accounts grouped by domain sorted by accounts' do
  585. 2.times { Fabricate(:account, domain: 'example.com') }
  586. Fabricate(:account, domain: 'example2.com')
  587. results = Account.by_domain_accounts
  588. expect(results.length).to eq 2
  589. expect(results.first.domain).to eq 'example.com'
  590. expect(results.first.accounts_count).to eq 2
  591. expect(results.last.domain).to eq 'example2.com'
  592. expect(results.last.accounts_count).to eq 1
  593. end
  594. end
  595. describe 'local' do
  596. it 'returns an array of accounts who do not have a domain' do
  597. account_1 = Fabricate(:account, domain: nil)
  598. account_2 = Fabricate(:account, domain: 'example.com')
  599. expect(Account.local).to match_array([account_1])
  600. end
  601. end
  602. describe 'partitioned' do
  603. it 'returns a relation of accounts partitioned by domain' do
  604. matches = ['a', 'b', 'a', 'b']
  605. matches.size.times.to_a.shuffle.each do |index|
  606. matches[index] = Fabricate(:account, domain: matches[index])
  607. end
  608. expect(Account.partitioned).to match_array(matches)
  609. end
  610. end
  611. describe 'recent' do
  612. it 'returns a relation of accounts sorted by recent creation' do
  613. matches = 2.times.map { Fabricate(:account) }
  614. expect(Account.recent).to match_array(matches)
  615. end
  616. end
  617. describe 'silenced' do
  618. it 'returns an array of accounts who are silenced' do
  619. account_1 = Fabricate(:account, silenced: true)
  620. account_2 = Fabricate(:account, silenced: false)
  621. expect(Account.silenced).to match_array([account_1])
  622. end
  623. end
  624. describe 'suspended' do
  625. it 'returns an array of accounts who are suspended' do
  626. account_1 = Fabricate(:account, suspended: true)
  627. account_2 = Fabricate(:account, suspended: false)
  628. expect(Account.suspended).to match_array([account_1])
  629. end
  630. end
  631. end
  632. context 'when is local' do
  633. # Test disabled because test environment omits autogenerating keys for performance
  634. xit 'generates keys' do
  635. account = Account.create!(domain: nil, username: Faker::Internet.user_name(nil, ['_']))
  636. expect(account.keypair.private?).to eq true
  637. end
  638. end
  639. context 'when is remote' do
  640. it 'does not generate keys' do
  641. key = OpenSSL::PKey::RSA.new(1024).public_key
  642. account = Account.create!(domain: 'remote', username: Faker::Internet.user_name(nil, ['_']), public_key: key.to_pem)
  643. expect(account.keypair.params).to eq key.params
  644. end
  645. it 'normalizes domain' do
  646. account = Account.create!(domain: 'にゃん', username: Faker::Internet.user_name(nil, ['_']))
  647. expect(account.domain).to eq 'xn--r9j5b5b'
  648. end
  649. end
  650. include_examples 'AccountAvatar', :account
  651. end