diff --git "a/train.csv" "b/train.csv" new file mode 100644--- /dev/null +++ "b/train.csv" @@ -0,0 +1,288440 @@ +INSTRUCTION;SOLUTION +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class TagFollowingService + def initialize(user=nil) + @user = user + end + + def create(name) + name_normalized = ActsAsTaggableOn::Tag.normalize(name) + raise ArgumentError, ""Name field null or empty"" if name_normalized.blank? + + tag = ActsAsTaggableOn::Tag.find_or_create_by(name: name_normalized) + raise DuplicateTag if @user.tag_followings.exists?(tag_id: tag.id) + + tag_following = @user.tag_followings.new(tag_id: tag.id) + raise ""Can't process tag entity"" unless tag_following.save + + tag + end + + def find(name) + name_normalized = ActsAsTaggableOn::Tag.normalize(name) + ActsAsTaggableOn::Tag.find_or_create_by(name: name_normalized) + end + + def destroy(id) + tag_following = @user.tag_followings.find_by!(tag_id: id) + tag_following.destroy + end + + def destroy_by_name(name) + name_normalized = ActsAsTaggableOn::Tag.normalize(name) + followed_tag = @user.followed_tags.find_by!(name: name_normalized) + destroy(followed_tag.id) + end + + def index + @user.followed_tags + end + + class DuplicateTag < RuntimeError; end +end + +```";"# frozen_string_literal: true + +describe TagFollowingService do + before do + add_tag(""tag1"", alice) + add_tag(""tag2"", alice) + end + + describe ""#create"" do + it ""Creates new tag with valid name"" do + name = SecureRandom.uuid + expect(alice.followed_tags.find_by(name: name)).to be_nil + tag_data = tag_following_service(alice).create(name) + expect(alice.followed_tags.find_by(name: name).name).to eq(name) + expect(tag_data[""name""]).to eq(name) + expect(tag_data[""id""]).to be_truthy + expect(tag_data[""taggings_count""]).to eq(0) + end + + it ""Throws error with empty tag"" do + expect { tag_following_service(alice).create(nil) }.to raise_error(ArgumentError) + expect { tag_following_service(alice).create("""") }.to raise_error(ArgumentError) + expect { tag_following_service(alice).create(""#"") }.to raise_error(ArgumentError) + expect { tag_following_service(alice).create("" "") }.to raise_error(ArgumentError) + end + + it ""throws an error when trying to follow an already followed tag"" do + name = SecureRandom.uuid + tag_following_service.create(name) + expect { + tag_following_service.create(name) + }.to raise_error TagFollowingService::DuplicateTag + end + end + + describe ""#destroy"" do + it ""Deletes tag with valid name"" do + name = SecureRandom.uuid + add_tag(name, alice) + expect(alice.followed_tags.find_by(name: name).name).to eq(name) + expect(tag_following_service(alice).destroy_by_name(name)).to be_truthy + expect(alice.followed_tags.find_by(name: name)).to be_nil + end + + it ""Deletes tag with id"" do + name = SecureRandom.uuid + new_tag = add_tag(name, alice) + expect(alice.followed_tags.find_by(name: name).name).to eq(name) + expect(tag_following_service(alice).destroy(new_tag.tag_id)).to be_truthy + expect(alice.followed_tags.find_by(name: name)).to be_nil + end + + it ""Does nothing with tag that isn't already followed"" do + original_length = alice.followed_tags.length + expect { + tag_following_service(alice).destroy_by_name(SecureRandom.uuid) + }.to raise_error ActiveRecord::RecordNotFound + expect { + tag_following_service(alice).destroy(-1) + }.to raise_error ActiveRecord::RecordNotFound + expect(alice.followed_tags.length).to eq(original_length) + end + + it ""Does nothing with empty tag name"" do + original_length = alice.followed_tags.length + expect { + tag_following_service(alice).destroy_by_name("""") + }.to raise_error ActiveRecord::RecordNotFound + expect(alice.followed_tags.length).to eq(original_length) + end + end + + describe ""#index"" do + it ""Returns user's list of tags"" do + tags = tag_following_service(alice).index + expect(tags.length).to eq(alice.followed_tags.length) + end + end + + private + + def tag_following_service(user=alice) + TagFollowingService.new(user) + end + + def add_tag(name, user) + tag = ActsAsTaggableOn::Tag.find_or_create_by(name: name) + tag_following = user.tag_followings.new(tag_id: tag.id) + tag_following.save + tag_following + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class AspectsMembershipService + def initialize(user=nil) + @user = user + end + + def create(aspect_id, person_id) + person = Person.find(person_id) + aspect = @user.aspects.where(id: aspect_id).first + raise ActiveRecord::RecordNotFound unless person.present? && aspect.present? + + contact = @user.share_with(person, aspect) + raise I18n.t(""aspects.add_to_aspect.failure"") if contact.blank? + + AspectMembership.where(contact_id: contact.id, aspect_id: aspect.id).first + end + + def destroy_by_ids(aspect_id, contact_id) + aspect = @user.aspects.where(id: aspect_id).first + contact = @user.contacts.where(person_id: contact_id).first + destroy(aspect, contact) + end + + def destroy_by_membership_id(membership_id) + aspect = @user.aspects.joins(:aspect_memberships).where(aspect_memberships: {id: membership_id}).first + contact = @user.contacts.joins(:aspect_memberships).where(aspect_memberships: {id: membership_id}).first + destroy(aspect, contact) + end + + def contacts_in_aspect(aspect_id) + order = [Arel.sql(""contact_id IS NOT NULL DESC""), ""profiles.first_name ASC"", ""profiles.last_name ASC"", + ""profiles.diaspora_handle ASC""] + @user.aspects.find(aspect_id) # to provide better error code if aspect isn't correct + contacts = @user.contacts.arel_table + aspect_memberships = AspectMembership.arel_table + @user.contacts.joins( + contacts.join(aspect_memberships).on( + aspect_memberships[:aspect_id].eq(aspect_id).and( + aspect_memberships[:contact_id].eq(contacts[:id]) + ) + ).join_sources + ).includes(person: :profile).order(order) + end + + def all_contacts + order = [""profiles.first_name ASC"", ""profiles.last_name ASC"", + ""profiles.diaspora_handle ASC""] + @user.contacts.includes(person: :profile).order(order) + end + + private + + def destroy(aspect, contact) + raise ActiveRecord::RecordNotFound unless aspect.present? && contact.present? + + raise Diaspora::NotMine unless @user.mine?(aspect) && @user.mine?(contact) + + membership = contact.aspect_memberships.where(aspect_id: aspect.id).first + raise ActiveRecord::RecordNotFound if membership.blank? + + success = membership.destroy + + {success: success, membership: membership} + end +end + +```";"# frozen_string_literal: true + +describe AspectsMembershipService do + before do + @alice_aspect1 = alice.aspects.first + @alice_aspect2 = alice.aspects.create(name: ""another aspect"") + @bob_aspect1 = bob.aspects.first + end + + describe ""#create"" do + context ""with valid IDs"" do + it ""succeeds"" do + membership = aspects_membership_service.create(@alice_aspect2.id, bob.person.id) + expect(membership[:aspect_id]).to eq(@alice_aspect2.id) + expect(@alice_aspect2.contacts.find_by(person_id: bob.person.id)).not_to be_nil + end + + it ""fails if already in aspect"" do + aspects_membership_service.create(@alice_aspect2.id, bob.person.id) + expect { + aspects_membership_service.create(@alice_aspect2.id, bob.person.id) + }.to raise_error ActiveRecord::RecordNotUnique + end + end + + context ""with invalid IDs"" do + it ""fails with invalid User ID"" do + expect { + aspects_membership_service.create(@alice_aspect2.id, -1) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails with invalid Aspect ID"" do + expect { + aspects_membership_service.create(-1, bob.person.id) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails with aspect ID that isn't user's"" do + expect { + aspects_membership_service.create(@bob_aspect1.id, eve.person.id) + }.to raise_error ActiveRecord::RecordNotFound + end + end + end + + describe ""#destroy"" do + before do + @membership = aspects_membership_service.create(@alice_aspect2.id, bob.person.id) + end + + context ""with aspect/user valid IDs"" do + it ""succeeds if in aspect"" do + aspects_membership_service.destroy_by_ids(@alice_aspect2.id, bob.person.id) + expect(@alice_aspect2.contacts.find_by(person_id: bob.person.id)).to be_nil + end + + it ""fails if not in aspect"" do + expect { + aspects_membership_service.destroy_by_ids(@alice_aspect2.id, eve.person.id) + }.to raise_error ActiveRecord::RecordNotFound + end + end + + context ""with a membership ID"" do + it ""succeeds if their membership"" do + aspects_membership_service.destroy_by_membership_id(@membership.id) + expect(@alice_aspect2.contacts.find_by(person_id: bob.person.id)).to be_nil + end + + it ""fails if not their membership"" do + expect { + aspects_membership_service(eve).destroy_by_membership_id(@membership.id) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails if invalid membership ID"" do + expect { + aspects_membership_service(eve).destroy_by_membership_id(-1) + }.to raise_error ActiveRecord::RecordNotFound + end + end + + context ""with invalid IDs"" do + it ""fails with invalid User ID"" do + expect { + aspects_membership_service.destroy_by_ids(@alice_aspect2.id, -1) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails with invalid Aspect ID"" do + expect { + aspects_membership_service.destroy_by_ids(-1, eve.person.id) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails with aspect ID that isn't user's"" do + expect { + aspects_membership_service(eve).destroy_by_ids(@alice_aspect2.id, bob.person.id) + }.to raise_error ActiveRecord::RecordNotFound + end + end + end + + describe ""#list"" do + before do + aspects_membership_service.create(@alice_aspect2.id, bob.person.id) + aspects_membership_service.create(@alice_aspect2.id, eve.person.id) + @alice_aspect3 = alice.aspects.create(name: ""empty aspect"") + end + + context ""with valid aspect ID"" do + it ""returns users in full aspect"" do + contacts = aspects_membership_service.contacts_in_aspect(@alice_aspect2.id) + expect(contacts.length).to eq(2) + expect(contacts.map {|c| c.person.guid }.sort).to eq([bob.person.guid, eve.person.guid].sort) + end + + it ""returns empty array in empty aspect"" do + contacts = aspects_membership_service.contacts_in_aspect(@alice_aspect3.id) + expect(contacts.length).to eq(0) + end + end + + context ""with invalid aspect ID"" do + it ""fails"" do + expect { + aspects_membership_service.contacts_in_aspect(-1) + }.to raise_error ActiveRecord::RecordNotFound + end + end + end + + describe ""#all_contacts"" do + before do + aspects_membership_service.create(@alice_aspect2.id, bob.person.id) + aspects_membership_service.create(@alice_aspect2.id, eve.person.id) + @alice_aspect3 = alice.aspects.create(name: ""empty aspect"") + end + + it ""returns all user's contacts"" do + contacts = aspects_membership_service.all_contacts + expect(contacts.length).to eq(2) + end + end + + def aspects_membership_service(user=alice) + AspectsMembershipService.new(user) + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class LikeService + def initialize(user=nil) + @user = user + end + + def create_for_post(post_id) + post = post_service.find!(post_id) + user.like!(post) + end + + def create_for_comment(comment_id) + comment = comment_service.find!(comment_id) + post_service.find!(comment.commentable_id) # checks implicit for visible posts + user.like_comment!(comment) + end + + def destroy(like_id) + like = Like.find(like_id) + if user.owns?(like) + user.retract(like) + true + else + false + end + end + + def find_for_post(post_id) + likes = post_service.find!(post_id).likes + user ? likes.order(Arel.sql(""author_id = #{user.person.id} DESC"")) : likes + end + + def find_for_comment(comment_id) + comment = comment_service.find!(comment_id) + post_service.find!(comment.post.id) # checks implicit for visible posts + likes = comment.likes + user ? likes.order(Arel.sql(""author_id = #{user.person.id} DESC"")) : likes + end + + def unlike_post(post_id) + likes = post_service.find!(post_id).likes + likes = likes.order(Arel.sql(""author_id = #{user.person.id} DESC"")) + if !likes.empty? && user.owns?(likes[0]) + user.retract(likes[0]) + true + else + false + end + end + + def unlike_comment(comment_id) + likes = comment_service.find!(comment_id).likes + likes = likes.order(Arel.sql(""author_id = #{user.person.id} DESC"")) + if !likes.empty? && user.owns?(likes[0]) + user.retract(likes[0]) + true + else + false + end + end + + private + + attr_reader :user + + def post_service + @post_service ||= PostService.new(user) + end + + def comment_service + @comment_service ||= CommentService.new(user) + end +end + +```";"# frozen_string_literal: true + +describe LikeService do + let(:post) { alice.post(:status_message, text: ""hello"", to: alice.aspects.first) } + let(:alice_comment) { CommentService.new(alice).create(post.id, ""This is a wonderful post"") } + let(:bobs_comment) { CommentService.new(bob).create(post.id, ""My post was better than yours"") } + + describe ""#create_for_post"" do + it ""creates a like on my own post"" do + expect { + LikeService.new(alice).create_for_post(post.id) + }.not_to raise_error + end + + it ""creates a like on a post of a contact"" do + expect { + LikeService.new(bob).create_for_post(post.id) + }.not_to raise_error + end + + it ""attaches the like to the post"" do + like = LikeService.new(alice).create_for_post(post.id) + expect(post.likes.first.id).to eq(like.id) + end + + it ""fails if the post does not exist"" do + expect { + LikeService.new(bob).create_for_post(""unknown id"") + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails if the user can't see the post"" do + expect { + LikeService.new(eve).create_for_post(post.id) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails if the user already liked the post"" do + LikeService.new(alice).create_for_post(post.id) + expect { + LikeService.new(alice).create_for_post(post.id) + }.to raise_error ActiveRecord::RecordInvalid + end + end + + describe ""#create_for_comment"" do + it ""creates a like on a posts comment"" do + expect { + LikeService.new(alice).create_for_comment(alice_comment.id) + }.not_to raise_error + end + + it ""creates a like on someone else comment"" do + expect { + LikeService.new(alice).create_for_comment(bobs_comment.id) + }.not_to raise_error + end + + it ""attaches the like to the comment"" do + like = LikeService.new(alice).create_for_comment(bobs_comment.id) + expect(bobs_comment.likes.first.id).to eq(like.id) + end + + it ""fails if comment does not exist"" do + expect { + LikeService.new(alice).create_for_comment(""unknown_id"") + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails if user cant see post and its comments"" do + expect { + LikeService.new(eve).create_for_comment(bobs_comment.id) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails if user already liked the comment"" do + LikeService.new(alice).create_for_comment(bobs_comment.id) + expect { + LikeService.new(alice).create_for_comment(bobs_comment.id) + }.to raise_error ActiveRecord::RecordInvalid + end + end + + describe ""#destroy"" do + context ""for post like"" do + let(:like) { LikeService.new(bob).create_for_post(post.id) } + + it ""lets the user destroy their own like"" do + result = LikeService.new(bob).destroy(like.id) + expect(result).to be_truthy + end + + it ""doesn't let the parent author destroy others likes"" do + result = LikeService.new(alice).destroy(like.id) + expect(result).to be_falsey + end + + it ""doesn't let someone destroy others likes"" do + result = LikeService.new(eve).destroy(like.id) + expect(result).to be_falsey + end + + it ""fails if the like doesn't exist"" do + expect { + LikeService.new(bob).destroy(""unknown id"") + }.to raise_error ActiveRecord::RecordNotFound + end + end + + context ""for comment like"" do + let(:like) { LikeService.new(bob).create_for_comment(alice_comment.id) } + + it ""let the user destroy its own comment like"" do + result = LikeService.new(bob).destroy(like.id) + expect(result).to be_truthy + end + + it ""doesn't let the parent author destroy other comment likes"" do + result = LikeService.new(alice).destroy(like.id) + expect(result).to be_falsey + end + + it ""fails if the like doesn't exist"" do + expect { + LikeService.new(alice).destroy(""unknown id"") + }.to raise_error ActiveRecord::RecordNotFound + end + end + end + + describe ""#find_for_post"" do + context ""with user"" do + it ""returns likes for a public post"" do + post = alice.post(:status_message, text: ""hello"", public: true) + like = LikeService.new(alice).create_for_post(post.id) + expect(LikeService.new(eve).find_for_post(post.id)).to include(like) + end + + it ""returns likes for a visible private post"" do + like = LikeService.new(alice).create_for_post(post.id) + expect(LikeService.new(bob).find_for_post(post.id)).to include(like) + end + + it ""doesn't return likes for a private post the user can not see"" do + LikeService.new(alice).create_for_post(post.id) + expect { + LikeService.new(eve).find_for_post(post.id) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""returns the user's like first"" do + post = alice.post(:status_message, text: ""hello"", public: true) + [alice, bob, eve].map {|user| LikeService.new(user).create_for_post(post.id) } + + [alice, bob, eve].each do |user| + expect( + LikeService.new(user).find_for_post(post.id).first.author.id + ).to be user.person.id + end + end + end + + context ""without user"" do + it ""returns likes for a public post"" do + post = alice.post(:status_message, text: ""hello"", public: true) + like = LikeService.new(alice).create_for_post(post.id) + expect(LikeService.new.find_for_post(post.id)).to include(like) + end + + it ""doesn't return likes a for private post"" do + LikeService.new(alice).create_for_post(post.id) + expect { + LikeService.new.find_for_post(post.id) + }.to raise_error Diaspora::NonPublic + end + end + + it ""returns all likes of a post"" do + post = alice.post(:status_message, text: ""hello"", public: true) + likes = [alice, bob, eve].map {|user| LikeService.new(user).create_for_post(post.id) } + + expect(LikeService.new.find_for_post(post.id)).to match_array(likes) + end + end + + describe ""#find_for_comment"" do + context ""with user"" do + it ""returns likes for a public post comment"" do + post = alice.post(:status_message, text: ""hello"", public: true) + comment = CommentService.new(bob).create(post.id, ""Hello comment"") + like = LikeService.new(alice).create_for_comment(comment.id) + expect(LikeService.new(eve).find_for_comment(comment.id)).to include(like) + end + + it ""returns likes for visible private post comments"" do + comment = CommentService.new(bob).create(post.id, ""Hello comment"") + like = LikeService.new(alice).create_for_comment(comment.id) + expect(LikeService.new(bob).find_for_comment(comment.id)).to include(like) + end + + it ""doesn't return likes for a posts comment the user can not see"" do + expect { + LikeService.new(eve).find_for_comment(alice_comment.id) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""returns the user's like first"" do + post = alice.post(:status_message, text: ""hello"", public: true) + comment = CommentService.new(alice).create(post.id, ""I like my own post"") + + [alice, bob, eve].map {|user| LikeService.new(user).create_for_comment(comment.id) } + [alice, bob, eve].each do |user| + expect( + LikeService.new(user).find_for_comment(comment.id).first.author.id + ).to be user.person.id + end + end + end + + context ""without user"" do + it ""returns likes for a comment on a public post"" do + post = alice.post(:status_message, text: ""hello"", public: true) + comment = CommentService.new(bob).create(post.id, ""I like my own post"") + like = LikeService.new(alice).create_for_comment(comment.id) + expect( + LikeService.new.find_for_comment(comment.id) + ).to include(like) + end + + it ""doesn't return likes for a private post comment"" do + LikeService.new(alice).create_for_comment(alice_comment.id) + expect { + LikeService.new.find_for_comment(alice_comment.id) + }.to raise_error Diaspora::NonPublic + end + end + end + + describe ""#unlike_post"" do + before do + LikeService.new(alice).create_for_post(post.id) + end + + it ""removes the like to the post"" do + LikeService.new(alice).unlike_post(post.id) + expect(post.likes.length).to eq(0) + end + end + + describe ""#unlike_comment"" do + it ""removes the like for a comment"" do + comment = CommentService.new(alice).create(post.id, ""I like my own post"") + LikeService.new(alice).create_for_comment(comment.id) + expect(comment.likes.length).to eq(1) + + LikeService.new(alice).unlike_comment(comment.id) + comment = CommentService.new(alice).find!(comment.id) + expect(comment.likes.length).to eq(0) + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class StatusMessageCreationService + include Rails.application.routes.url_helpers + + def initialize(user) + @user = user + end + + def create(params) + validate_content(params) + + build_status_message(params).tap do |status_message| + load_aspects(params[:aspect_ids]) unless status_message.public? + add_attachments(status_message, params) + status_message.save + process(status_message, params[:services]) + end + end + + private + + attr_reader :user, :aspects + + def validate_content(params) + raise MissingContent unless params[:status_message][:text].present? || params[:photos].present? + end + + def build_status_message(params) + public = params[:public] || false + user.build_post(:status_message, params[:status_message].merge(public: public)) + end + + def add_attachments(status_message, params) + add_location(status_message, params[:location_address], params[:location_coords]) + add_poll(status_message, params) + add_photos(status_message, params[:photos]) + end + + def add_location(status_message, address, coordinates) + status_message.build_location(address: address, coordinates: coordinates) if address.present? + end + + def add_poll(status_message, params) + if params[:poll_question].present? + status_message.build_poll(question: params[:poll_question]) + [*params[:poll_answers]].each do |poll_answer| + answer = status_message.poll.poll_answers.build(answer: poll_answer) + answer.poll = status_message.poll + end + end + end + + def add_photos(status_message, photos) + if photos.present? + status_message.photos << Photo.where(id: photos, author_id: status_message.author_id) + status_message.photos.each do |photo| + photo.public = status_message.public + photo.pending = false + end + end + end + + def load_aspects(aspect_ids) + @aspects = user.aspects_from_ids(aspect_ids) + raise BadAspectsIDs if aspects.empty? + end + + def process(status_message, services) + add_to_streams(status_message) unless status_message.public? + dispatch(status_message, services) + end + + def add_to_streams(status_message) + user.add_to_streams(status_message, aspects) + status_message.photos.each {|photo| user.add_to_streams(photo, aspects) } + end + + def dispatch(status_message, services) + receiving_services = services ? Service.titles(services) : [] + status_message.filter_mentions # this is only required until changes from #6818 are deployed on every pod + user.dispatch_post(status_message, + url: short_post_url(status_message.guid, host: AppConfig.environment.url), + service_types: receiving_services) + end + + class BadAspectsIDs < RuntimeError + end + + class MissingContent < RuntimeError + end +end + +```";"# frozen_string_literal: true + +describe StatusMessageCreationService do + describe ""#create"" do + let(:aspect) { alice.aspects.first } + let(:text) { ""I'm writing tests"" } + let(:params) { + { + status_message: {text: text}, + aspect_ids: [aspect.id.to_s] + } + } + + it ""returns the created StatusMessage"" do + status_message = StatusMessageCreationService.new(alice).create(params) + expect(status_message).to_not be_nil + expect(status_message.text).to eq(text) + end + + context ""with aspect_ids"" do + it ""creates aspect_visibilities for the StatusMessages"" do + alice.aspects.create(name: ""another aspect"") + + status_message = StatusMessageCreationService.new(alice).create(params) + expect(status_message.aspect_visibilities.map(&:aspect)).to eq([aspect]) + end + + it ""does not create aspect_visibilities if the post is public"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(public: true)) + expect(status_message.aspect_visibilities).to be_empty + end + + it ""raises exception if aspects_ids don't contain any applicable aspect identifiers"" do + bad_ids = [Aspect.ids.max.next, bob.aspects.first.id].map(&:to_s) + expect { + StatusMessageCreationService.new(alice).create(params.merge(aspect_ids: bad_ids)) + }.to remain(StatusMessage, :count).and raise_error(StatusMessageCreationService::BadAspectsIDs) + end + end + + context ""with public"" do + it ""it creates a private StatusMessage by default"" do + status_message = StatusMessageCreationService.new(alice).create(params) + expect(status_message.public).to be_falsey + end + + it ""it creates a private StatusMessage"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(public: false)) + expect(status_message.public).to be_falsey + end + + it ""it creates a public StatusMessage"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(public: true)) + expect(status_message.public).to be_truthy + end + end + + context ""with location"" do + it ""it creates a location"" do + location_params = {location_address: ""somewhere"", location_coords: ""1,2""} + status_message = StatusMessageCreationService.new(alice).create(params.merge(location_params)) + location = status_message.location + expect(location.address).to eq(""somewhere"") + expect(location.lat).to eq(""1"") + expect(location.lng).to eq(""2"") + end + + it ""does not add a location without location params"" do + status_message = StatusMessageCreationService.new(alice).create(params) + expect(status_message.location).to be_nil + end + end + + context ""with poll"" do + it ""it creates a poll"" do + poll_params = {poll_question: ""something?"", poll_answers: %w(yes no maybe)} + status_message = StatusMessageCreationService.new(alice).create(params.merge(poll_params)) + poll = status_message.poll + expect(poll.question).to eq(""something?"") + expect(poll.poll_answers.size).to eq(3) + poll_answers = poll.poll_answers.map(&:answer) + expect(poll_answers).to include(""yes"") + expect(poll_answers).to include(""no"") + expect(poll_answers).to include(""maybe"") + end + + it ""does not add a poll without poll params"" do + status_message = StatusMessageCreationService.new(alice).create(params) + expect(status_message.poll).to be_nil + end + end + + context ""with photos"" do + let(:photo1) { + alice.build_post(:photo, pending: true, user_file: File.open(photo_fixture_name), to: aspect.id).tap(&:save!) + } + let(:photo2) { + alice.build_post(:photo, pending: true, user_file: File.open(photo_fixture_name), to: aspect.id).tap(&:save!) + } + let(:photo_ids) { [photo1.id.to_s, photo2.id.to_s] } + + it ""it attaches all photos"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(photos: photo_ids)) + photos = status_message.photos + expect(photos.size).to eq(2) + expect(photos.map(&:id).map(&:to_s)).to match_array(photo_ids) + end + + it ""does not attach photos without photos param"" do + status_message = StatusMessageCreationService.new(alice).create(params) + expect(status_message.photos).to be_empty + end + + context ""with aspect_ids"" do + it ""it marks the photos as non-public if the post is non-public"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(photos: photo_ids)) + status_message.photos.each do |photo| + expect(photo.public).to be_falsey + end + end + + it ""creates aspect_visibilities for the Photo"" do + alice.aspects.create(name: ""another aspect"") + + status_message = StatusMessageCreationService.new(alice).create(params.merge(photos: photo_ids)) + status_message.photos.each do |photo| + expect(photo.aspect_visibilities.map(&:aspect)).to eq([aspect]) + end + end + + it ""does not create aspect_visibilities if the post is public"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(photos: photo_ids, public: true)) + status_message.photos.each do |photo| + expect(photo.aspect_visibilities).to be_empty + end + end + + it ""sets pending to false on any attached photos"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(photos: photo_ids)) + status_message.photos.each do |photo| + expect(photo.reload.pending).to be_falsey + end + end + end + + context ""with public"" do + it ""it marks the photos as public if the post is public"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(photos: photo_ids, public: true)) + status_message.photos.each do |photo| + expect(photo.public).to be_truthy + end + end + + it ""sets pending to false on any attached photos"" do + status_message = StatusMessageCreationService.new(alice).create(params.merge(photos: photo_ids, public: true)) + status_message.photos.each do |photo| + expect(photo.reload.pending).to be_falsey + end + end + end + end + + context ""dispatch"" do + it ""dispatches the StatusMessage"" do + expect(alice).to receive(:dispatch_post).with(instance_of(StatusMessage), hash_including(service_types: [])) + StatusMessageCreationService.new(alice).create(params) + end + + it ""dispatches the StatusMessage to services"" do + expect(alice).to receive(:dispatch_post) + .with(instance_of(StatusMessage), + hash_including(service_types: array_including(%w[Services::Tumblr Services::Twitter]))) + StatusMessageCreationService.new(alice).create(params.merge(services: %w[twitter tumblr])) + end + + context ""with mention"" do + let(:text) { text_mentioning(eve) } + + # this is only required until changes from #6818 are deployed on every pod + it ""filters out mentions from text attribute"" do + status_message = StatusMessageCreationService.new(alice).create(params) + expect(status_message.text).not_to include(eve.diaspora_handle) + end + end + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class PostService + def initialize(user=nil) + @user = user + end + + def find(id) + if user + user.find_visible_shareable_by_id(Post, id) + else + Post.find_by_id_and_public(id, true) + end + end + + def find!(id_or_guid) + if user + find_non_public_by_guid_or_id_with_user!(id_or_guid) + else + find_public!(id_or_guid) + end + end + + def present_json + PostPresenter.new(post, user) + end + + def present_interactions_json + PostInteractionPresenter.new(post, user) + end + + def mark_user_notifications(post_id) + return unless user + mark_comment_reshare_like_notifications_read(post_id) + mark_mention_notifications_read(post_id) + end + + def destroy(post_id, private_allowed=true) + post = if private_allowed + find_non_public_by_guid_or_id_with_user!(post_id) + else + find_public!(post_id) + end + raise Diaspora::NotMine unless post.author == user.person + + user.retract(post) + end + + def mentionable_in_comment(post_id, query) + post = find!(post_id) + Person + .allowed_to_be_mentioned_in_a_comment_to(post) + .where.not(id: user.person_id) + .find_by_substring(query) + .sort_for_mention_suggestion(post, user) + .for_json + .limit(15) + end + + private + + attr_reader :user + + def find_public!(id_or_guid) + Post.where(post_key(id_or_guid) => id_or_guid).first.tap do |post| + raise ActiveRecord::RecordNotFound, ""could not find a post with id #{id_or_guid}"" unless post + raise Diaspora::NonPublic unless post.public? + end + end + + def find_non_public_by_guid_or_id_with_user!(id_or_guid) + user.find_visible_shareable_by_id(Post, id_or_guid, key: post_key(id_or_guid)).tap do |post| + raise ActiveRecord::RecordNotFound, ""could not find a post with id #{id_or_guid} for user #{user.id}"" unless post + end + end + + # We can assume a guid is at least 16 characters long as we have guids set to hex(8) since we started using them. + def post_key(id_or_guid) + id_or_guid.to_s.length < 16 ? :id : :guid + end + + def mark_comment_reshare_like_notifications_read(post_id) + Notification.where(recipient_id: user.id, target_type: ""Post"", target_id: post_id, unread: true) + .update_all(unread: false) + end + + def mark_mention_notifications_read(post_id) + mention_ids = Mention.where( + mentions_container_id: post_id, + mentions_container_type: ""Post"", + person_id: user.person_id + ).ids + mention_ids.concat(mentions_in_comments_for_post(post_id).pluck(:id)) + + Notification.where(recipient_id: user.id, target_type: ""Mention"", target_id: mention_ids, unread: true) + .update_all(unread: false) if mention_ids.any? + end + + def mentions_in_comments_for_post(post_id) + Mention + .joins(""INNER JOIN comments ON mentions_container_id = comments.id AND mentions_container_type = 'Comment'"") + .where(comments: {commentable_id: post_id, commentable_type: ""Post""}) + end +end + +```";"# frozen_string_literal: true + +describe PostService do + let(:post) { alice.post(:status_message, text: ""ohai"", to: alice.aspects.first) } + let(:public) { alice.post(:status_message, text: ""hey"", public: true) } + + describe ""#find"" do + context ""with user"" do + it ""returns the post, if it is the users post"" do + expect(PostService.new(alice).find(post.id)).to eq(post) + end + + it ""returns the post, if the user can see the it"" do + expect(PostService.new(bob).find(post.id)).to eq(post) + end + + it ""returns the post, if it is public"" do + expect(PostService.new(eve).find(public.id)).to eq(public) + end + + it ""does not return the post, if the post cannot be found"" do + expect(PostService.new(alice).find(""unknown"")).to be_nil + end + + it ""does not return the post, if user cannot see the post"" do + expect(PostService.new(eve).find(post.id)).to be_nil + end + end + + context ""without user"" do + it ""returns the post, if it is public"" do + expect(PostService.new.find(public.id)).to eq(public) + end + + it ""does not return the post, if the post is private"" do + expect(PostService.new.find(post.id)).to be_nil + end + + it ""does not return the post, if the post cannot be found"" do + expect(PostService.new.find(""unknown"")).to be_nil + end + end + end + + describe ""#find!"" do + context ""with user"" do + it ""returns the post, if it is the users post"" do + expect(PostService.new(alice).find!(post.id)).to eq(post) + end + + it ""works with guid"" do + expect(PostService.new(alice).find!(post.guid)).to eq(post) + end + + it ""returns the post, if the user can see the it"" do + expect(PostService.new(bob).find!(post.id)).to eq(post) + end + + it ""returns the post, if it is public"" do + expect(PostService.new(eve).find!(public.id)).to eq(public) + end + + it ""RecordNotFound if the post cannot be found"" do + expect { + PostService.new(alice).find!(""unknown"") + }.to raise_error ActiveRecord::RecordNotFound, ""could not find a post with id unknown for user #{alice.id}"" + end + + it ""RecordNotFound if user cannot see the post"" do + expect { + PostService.new(eve).find!(post.id) + }.to raise_error ActiveRecord::RecordNotFound, ""could not find a post with id #{post.id} for user #{eve.id}"" + end + end + + context ""without user"" do + it ""returns the post, if it is public"" do + expect(PostService.new.find!(public.id)).to eq(public) + end + + it ""works with guid"" do + expect(PostService.new.find!(public.guid)).to eq(public) + end + + it ""NonPublic if the post is private"" do + expect { + PostService.new.find!(post.id) + }.to raise_error Diaspora::NonPublic + end + + it ""RecordNotFound if the post cannot be found"" do + expect { + PostService.new.find!(""unknown"") + }.to raise_error ActiveRecord::RecordNotFound, ""could not find a post with id unknown"" + end + end + + context ""id/guid switch"" do + let(:public) { alice.post(:status_message, text: ""ohai"", public: true) } + + it ""assumes ids less than 16 chars are ids and not guids"" do + post = Post.where(id: public.id) + expect(Post).to receive(:where).with(hash_including(id: ""123456789012345"")).and_return(post).at_least(:once) + PostService.new(alice).find!(""123456789012345"") + end + + it ""assumes ids more than (or equal to) 16 chars are actually guids"" do + post = Post.where(guid: public.guid) + expect(Post).to receive(:where).with(hash_including(guid: ""1234567890123456"")).and_return(post).at_least(:once) + PostService.new(alice).find!(""1234567890123456"") + end + end + end + + describe ""#mark_user_notifications"" do + let(:status_text) { text_mentioning(alice) } + + it ""marks a corresponding notifications as read"" do + FactoryBot.create(:notification, recipient: alice, target: post, unread: true) + FactoryBot.create(:notification, recipient: alice, target: post, unread: true) + + expect { + PostService.new(alice).mark_user_notifications(post.id) + }.to change(Notification.where(unread: true), :count).by(-2) + end + + it ""marks a corresponding mention notification as read"" do + mention_post = bob.post(:status_message, text: status_text, public: true) + + expect { + PostService.new(alice).mark_user_notifications(mention_post.id) + }.to change(Notification.where(unread: true), :count).by(-1) + end + + it ""marks a corresponding mention in comment notification as read"" do + notification = FactoryBot.create(:notification_mentioned_in_comment) + status_message = notification.target.mentions_container.parent + user = notification.recipient + + expect { + PostService.new(user).mark_user_notifications(status_message.id) + }.to change(Notification.where(unread: true), :count).by(-1) + end + + it ""does not change the update_at date/time for post notifications"" do + notification = Timecop.travel(1.minute.ago) do + FactoryBot.create(:notification, recipient: alice, target: post, unread: true) + end + + expect { + PostService.new(alice).mark_user_notifications(post.id) + }.not_to change { Notification.where(id: notification.id).pluck(:updated_at) } + end + + it ""does not change the update_at date/time for mention notifications"" do + mention_post = Timecop.travel(1.minute.ago) do + bob.post(:status_message, text: status_text, public: true) + end + mention = mention_post.mentions.where(person_id: alice.person.id).first + + expect { + PostService.new(alice).mark_user_notifications(post.id) + }.not_to change { Notification.where(target_type: ""Mention"", target_id: mention.id).pluck(:updated_at) } + end + + it ""does nothing without a user"" do + expect_any_instance_of(PostService).not_to receive(:mark_comment_reshare_like_notifications_read).with(post.id) + expect_any_instance_of(PostService).not_to receive(:mark_mention_notifications_read).with(post.id) + PostService.new.mark_user_notifications(post.id) + end + end + + describe ""#destroy"" do + it ""let a user delete his message"" do + PostService.new(alice).destroy(post.id) + expect(StatusMessage.find_by_id(post.id)).to be_nil + end + + it ""sends a retraction on delete"" do + expect(alice).to receive(:retract).with(post) + PostService.new(alice).destroy(post.id) + end + + it ""won't delete private post if explicitly unallowed"" do + expect { + PostService.new(alice).destroy(post.id, false) + }.to raise_error Diaspora::NonPublic + expect(StatusMessage.find_by(id: post.id)).not_to be_nil + end + + it ""will not let you destroy posts visible to you but that you do not own"" do + expect { + PostService.new(bob).destroy(post.id) + }.to raise_error Diaspora::NotMine + expect(StatusMessage.find_by_id(post.id)).not_to be_nil + end + + it ""will not let you destroy posts that are not visible to you"" do + expect { + PostService.new(eve).destroy(post.id) + }.to raise_error(ActiveRecord::RecordNotFound) + expect(StatusMessage.find_by_id(post.id)).not_to be_nil + end + end + + describe ""#mentionable_in_comment"" do + describe ""semi-integration test"" do + let(:post_author_attributes) { {first_name: ""Ro#{r_str}""} } + let(:post_author) { FactoryBot.create(:person, post_author_attributes) } + let(:current_user) { FactoryBot.create(:user_with_aspect) } + let(:post_service) { PostService.new(current_user) } + + shared_context ""with commenters and likers"" do + # randomize ids of the created people so that the test doesn't pass just because of + # the id sequence matched against the expected ordering + let(:ids) { (1..4).map {|i| Person.maximum(:id) + i }.shuffle } + + before do + # in case when post_author has't been instantiated before this context, specify id + # in order to avoid id conflict with the people generated here + post_author_attributes.merge!(id: ids.max + 1) + end + + let!(:commenter1) { + FactoryBot.create(:person, id: ids.shift, first_name: ""Ro1#{r_str}"").tap {|person| + FactoryBot.create(:comment, author: person, post: post) + } + } + + let!(:commenter2) { + FactoryBot.create(:person, id: ids.shift, first_name: ""Ro2#{r_str}"").tap {|person| + FactoryBot.create(:comment, author: person, post: post) + } + } + + let!(:liker1) { + FactoryBot.create(:person, id: ids.shift, first_name: ""Ro1#{r_str}"").tap {|person| + FactoryBot.create(:like, author: person, target: post) + } + } + + let!(:liker2) { + FactoryBot.create(:person, id: ids.shift, first_name: ""Ro2#{r_str}"").tap {|person| + FactoryBot.create(:like, author: person, target: post) + } + } + end + + shared_context ""with a current user's friend"" do + let!(:current_users_friend) { + FactoryBot.create(:person).tap {|friend| + current_user.contacts.create!( + person: friend, + aspects: [current_user.aspects.first], + sharing: true, + receiving: true + ) + } + } + end + + context ""with private post"" do + let(:post) { FactoryBot.create(:status_message, text: ""ohai"", author: post_author) } + + context ""when the post doesn't have a visibility for the current user"" do + it ""doesn't find a post and raises an exception"" do + expect { + post_service.mentionable_in_comment(post.id, ""Ro"") + }.to raise_error(ActiveRecord::RecordNotFound) + end + end + + context ""when the post has a visibility for the current user"" do + before do + ShareVisibility.batch_import([current_user.id], post) + end + + context ""with commenters and likers"" do + include_context ""with commenters and likers"" + + it ""returns mention suggestions in the correct order"" do + expected_suggestions = [ + post_author, commenter1, commenter2, liker1, liker2 + ] + expect(post_service.mentionable_in_comment(post.id, ""Ro"")).to eq(expected_suggestions) + end + end + + context ""with a current user's friend"" do + include_context ""with a current user's friend"" + + it ""doesn't include a contact"" do + expect(post_service.mentionable_in_comment(post.id, current_users_friend.first_name)).to be_empty + end + end + + it ""doesn't include a non contact"" do + expect(post_service.mentionable_in_comment(post.id, eve.person.first_name)).to be_empty + end + end + end + + context ""with public post"" do + let(:post) { FactoryBot.create(:status_message, text: ""ohai"", public: true, author: post_author) } + + context ""with commenters and likers and with a current user's friend"" do + include_context ""with commenters and likers"" + include_context ""with a current user's friend"" + + it ""returns mention suggestions in the correct order"" do + result = post_service.mentionable_in_comment(post.id, ""Ro"").to_a + expect(result.size).to be > 7 + # participants: post author, comments, likers + expect(result[0..4]).to eq([post_author, commenter1, commenter2, liker1, liker2]) + # contacts + expect(result[5]).to eq(current_users_friend) + # non-contacts + result[6..-1].each {|person| + expect(person.contacts.where(user_id: current_user.id)).to be_empty + expect(person.profile.first_name).to include(""Ro"") + } + end + + it ""doesn't include people with non-matching names"" do + commenter = FactoryBot.create(:person, first_name: ""RRR#{r_str}"") + FactoryBot.create(:comment, author: commenter) + liker = FactoryBot.create(:person, first_name: ""RRR#{r_str}"") + FactoryBot.create(:like, author: liker) + friend = FactoryBot.create(:person, first_name: ""RRR#{r_str}"") + current_user.contacts.create!( + person: friend, + aspects: [current_user.aspects.first], + sharing: true, + receiving: true + ) + + result = post_service.mentionable_in_comment(post.id, ""Ro"") + expect(result).not_to include(commenter) + expect(result).not_to include(liker) + expect(result).not_to include(friend) + end + end + + shared_examples ""current user can't mention themself"" do + before do + current_user.profile.update(first_name: ""Ro#{r_str}"") + end + + it ""doesn't include current user"" do + expect(post_service.mentionable_in_comment(post.id, ""Ro"")).not_to include(current_user.person) + end + end + + context ""when current user is a post author"" do + let(:post_author) { current_user.person } + + include_examples ""current user can't mention themself"" + end + + context ""current user is a participant"" do + before do + current_user.like!(post) + current_user.comment!(post, ""hello"") + end + + include_examples ""current user can't mention themself"" + end + + context ""current user is a stranger matching a search pattern"" do + include_examples ""current user can't mention themself"" + end + + it ""doesn't fail when the post author doesn't match the requested pattern"" do + expect(post_service.mentionable_in_comment(post.id, ""#{r_str}#{r_str}#{r_str}"")).to be_empty + end + + it ""renders a commenter with multiple comments only once"" do + person = FactoryBot.create(:person, first_name: ""Ro2#{r_str}"") + 2.times { FactoryBot.create(:comment, author: person, post: post) } + expect(post_service.mentionable_in_comment(post.id, person.first_name).length).to eq(1) + end + end + end + + describe ""unit test"" do + let(:post_service) { PostService.new(alice) } + + before do + expect(post_service).to receive(:find!).and_return(post) + end + + it ""calls Person.allowed_to_be_mentioned_in_a_comment_to"" do + expect(Person).to receive(:allowed_to_be_mentioned_in_a_comment_to).with(post).and_call_original + post_service.mentionable_in_comment(post.id, ""whatever"") + end + + it ""calls Person.find_by_substring"" do + expect(Person).to receive(:find_by_substring).with(""whatever"").and_call_original + post_service.mentionable_in_comment(post.id, ""whatever"") + end + + it ""calls Person.sort_for_mention_suggestion"" do + expect(Person).to receive(:sort_for_mention_suggestion).with(post, alice).and_call_original + post_service.mentionable_in_comment(post.id, ""whatever"") + end + + it ""calls Person.limit"" do + 16.times { + FactoryBot.create(:comment, author: FactoryBot.create(:person, first_name: ""Ro#{r_str}""), post: post) + } + expect(post_service.mentionable_in_comment(post.id, ""Ro"").length).to eq(15) + end + + it ""contains a constraint on a current user"" do + expect(Person).to receive(:allowed_to_be_mentioned_in_a_comment_to) { Person.all } + expect(Person).to receive(:find_by_substring) { Person.all } + expect(Person).to receive(:sort_for_mention_suggestion) { Person.all } + expect(post_service.mentionable_in_comment(post.id, alice.person.first_name)) + .not_to include(alice.person) + end + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class NotificationService + NOTIFICATION_TYPES = { + Comment => [Notifications::MentionedInComment, Notifications::CommentOnPost, Notifications::AlsoCommented], + Like => [Notifications::Liked, Notifications::LikedComment], + StatusMessage => [Notifications::MentionedInPost], + Conversation => [Notifications::PrivateMessage], + Message => [Notifications::PrivateMessage], + Reshare => [Notifications::Reshared], + Contact => [Notifications::StartedSharing] + }.freeze + + NOTIFICATIONS_JSON_TYPES = { + ""also_commented"" => ""Notifications::AlsoCommented"", + ""comment_on_post"" => ""Notifications::CommentOnPost"", + ""liked"" => ""Notifications::Liked"", + ""liked_comment"" => ""Notifications::LikedComment"", + ""mentioned"" => ""Notifications::MentionedInPost"", + ""mentioned_in_comment"" => ""Notifications::MentionedInComment"", + ""reshared"" => ""Notifications::Reshared"", + ""started_sharing"" => ""Notifications::StartedSharing"", + ""contacts_birthday"" => ""Notifications::ContactsBirthday"" + }.freeze + + NOTIFICATIONS_REVERSE_JSON_TYPES = NOTIFICATIONS_JSON_TYPES.invert.freeze + + def initialize(user=nil) + @user = user + end + + def index(unread_only=nil, only_after=nil) + query_string = ""recipient_id = ? "" + query_string += ""AND unread = true "" if unread_only + where_clause = [query_string, @user.id] + if only_after + query_string += "" AND created_at >= ?"" + where_clause = [query_string, @user.id, only_after] + end + Notification.where(where_clause).includes(:target, actors: :profile) + end + + def get_by_guid(guid) + Notification.where(recipient_id: @user.id, guid: guid).first + end + + def update_status_by_guid(guid, is_read_status) + notification = get_by_guid(guid) + raise ActiveRecord::RecordNotFound unless notification + + notification.set_read_state(is_read_status) + true + end + + def notify(object, recipient_user_ids) + notification_types(object).each {|type| type.notify(object, recipient_user_ids) } + end + + private + + def notification_types(object) + NOTIFICATION_TYPES.fetch(object.class, []) + end +end + +```";"# frozen_string_literal: true + +describe NotificationService do + describe ""notification interrelation"" do + context ""with mention in comment"" do + let(:status_message) { + FactoryBot.create(:status_message, public: true, author: alice.person).tap {|status_message| + eve.comment!(status_message, ""whatever"") + } + } + + let(:comment) { + FactoryBot.create( + :comment, + author: bob.person, + text: text_mentioning(alice, eve), + post: status_message + ) + } + + it ""sends only mention notification"" do + [alice, eve].each do |user| + expect(Workers::Mail::MentionedInComment).to receive(:perform_async).with( + user.id, + bob.person.id, + *comment.mentions.where(person: user.person).ids + ) + end + + expect { + NotificationService.new.notify(comment, []) + }.to change { Notification.where(recipient_id: alice).count }.by(1) + .and change { Notification.where(recipient_id: eve).count }.by(1) + + [alice, eve].each do |user| + expect( + Notifications::MentionedInComment.where(target: comment.mentions, recipient_id: user.id) + ).to exist + + expect( + Notifications::CommentOnPost.where(target: comment.parent, recipient_id: user.id) + ).not_to exist + + expect( + Notifications::AlsoCommented.where(target: comment.parent, recipient_id: user.id) + ).not_to exist + end + end + + context ""with \""mentioned in comment\"" email turned off"" do + before do + alice.user_preferences.create(email_type: ""mentioned_in_comment"") + eve.user_preferences.create(email_type: ""mentioned_in_comment"") + end + + it ""calls appropriate mail worker instead"" do + expect(Workers::Mail::MentionedInComment).not_to receive(:perform_async) + + expect(Workers::Mail::CommentOnPost).to receive(:perform_async).with( + alice.id, + bob.person.id, + *comment.mentions.where(person: alice.person).ids + ) + + expect(Workers::Mail::AlsoCommented).to receive(:perform_async).with( + eve.id, + bob.person.id, + *comment.mentions.where(person: eve.person).ids + ) + + NotificationService.new.notify(comment, []) + end + end + end + end + + describe ""query methods"" do + before do + @post = alice.post( + :status_message, + text: ""This is a status message"", + public: true, + to: ""all"" + ) + @notification = FactoryBot.create(:notification, recipient: alice, target: @post) + @service = NotificationService.new(alice) + end + + describe ""#index"" do + it ""gets all"" do + notifications = @service.index + expect(notifications.length).to eq(1) + end + + it ""gets unread only"" do + notifications = @service.index(true) + expect(notifications.length).to eq(1) + @notification.set_read_state(true) + notifications = @service.index(true) + expect(notifications.length).to eq(0) + end + + it ""gets only after"" do + notifications = @service.index(nil, (Time.current - 1.day)) + expect(notifications.length).to eq(1) + @notification.set_read_state(true) + notifications = @service.index(nil, (Time.current + 1.day)) + expect(notifications.length).to eq(0) + end + + it ""combined filtering"" do + notifications = @service.index(true, (Time.current - 1.day)) + expect(notifications.length).to eq(1) + end + end + + describe ""#show"" do + it ""succeeds with valid GUID"" do + notification = @service.get_by_guid(@notification.guid) + expect(notification).not_to be_nil + end + end + + describe ""#update"" do + it ""succeeds with valid GUID"" do + expect(@service.update_status_by_guid(@notification.guid, true)).to be_truthy + expect(@notification.reload.unread).to eq(false) + expect(@service.update_status_by_guid(@notification.guid, false)).to be_truthy + expect(@notification.reload.unread).to eq(true) + end + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +# Encapsulates logic of processing diaspora:// links +class DiasporaLinkService + attr_reader :type, :author, :guid + + def initialize(link) + @link = link.dup + parse + end + + def find_or_fetch_entity + if type && guid + entity_finder.find || fetch_entity + elsif author + find_or_fetch_person + end + end + + private + + attr_accessor :link + + def fetch_entity + DiasporaFederation::Federation::Fetcher.fetch_public(author, type, guid) + entity_finder.find + rescue DiasporaFederation::Federation::Fetcher::NotFetchable + nil + end + + def entity_finder + @entity_finder ||= Diaspora::EntityFinder.new(type, guid) + end + + def find_or_fetch_person + Person.find_or_fetch_by_identifier(author) + rescue DiasporaFederation::Discovery::DiscoveryError + nil + end + + def normalize + link.gsub!(%r{^web\+diaspora://}, ""diaspora://"") || + link.gsub!(%r{^//}, ""diaspora://"") || + %r{^diaspora://}.match(link) || + self.link = ""diaspora://#{link}"" + end + + def parse + normalize + match = DiasporaFederation::Federation::DiasporaUrlParser::DIASPORA_URL_REGEX.match(link) + if match + @author, @type, @guid = match.captures + else + @author = %r{^diaspora://(#{Validation::Rule::DiasporaId::DIASPORA_ID_REGEX})$}u.match(link)&.captures&.first + end + end +end + +```";"# frozen_string_literal: true + +describe DiasporaLinkService do + let(:service) { described_class.new(link) } + + describe ""#find_or_fetch_entity"" do + context ""when entity is known"" do + let(:post) { FactoryBot.create(:status_message) } + let(:link) { ""diaspora://#{post.author.diaspora_handle}/post/#{post.guid}"" } + + it ""returns the entity"" do + expect(service.find_or_fetch_entity).to eq(post) + end + end + + context ""when entity is unknown"" do + let(:remote_person) { FactoryBot.create(:person) } + let(:guid) { ""1234567890abcdef"" } + let(:link) { ""diaspora://#{remote_person.diaspora_handle}/post/#{guid}"" } + + it ""fetches entity"" do + expect(DiasporaFederation::Federation::Fetcher) + .to receive(:fetch_public) + .with(remote_person.diaspora_handle, ""post"", guid) { + FactoryBot.create(:status_message, author: remote_person, guid: guid) + } + + entity = service.find_or_fetch_entity + expect(entity).to be_a(StatusMessage) + expect(entity.guid).to eq(guid) + expect(entity.author).to eq(remote_person) + end + + it ""returns nil when entity is non fetchable"" do + expect(DiasporaFederation::Federation::Fetcher) + .to receive(:fetch_public) + .with(remote_person.diaspora_handle, ""post"", guid) + .and_raise(DiasporaFederation::Federation::Fetcher::NotFetchable) + + expect(service.find_or_fetch_entity).to be_nil + end + end + + context ""with invalid links"" do + it ""returns nil when the link is invalid"" do + service = described_class.new(""web+diaspora://something_invalid"") + expect(service.find_or_fetch_entity).to be_nil + end + + it ""returns nil when the author is valid, but rest of the link is invalid"" do + service = described_class.new(""web+diaspora://#{alice.diaspora_handle}/foo/bar"") + expect(service.find_or_fetch_entity).to be_nil + end + end + + context ""with only a diaspora ID"" do + let(:person) { FactoryBot.create(:person) } + let(:link) { ""diaspora://#{person.diaspora_handle}"" } + + it ""returns the person"" do + expect(service.find_or_fetch_entity).to eq(person) + end + + it ""returns nil when person is non fetchable"" do + expect(Person).to receive(:find_or_fetch_by_identifier) + .with(person.diaspora_handle).and_raise(DiasporaFederation::Discovery::DiscoveryError) + + expect(service.find_or_fetch_entity).to be_nil + end + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class PollParticipationService + def initialize(user) + @user = user + end + + def vote(post_id, answer_id) + answer = PollAnswer.find(answer_id) + @user.participate_in_poll!(target(post_id), answer) if target(post_id) + end + + private + + def target(post_id) + @target ||= @user.find_visible_shareable_by_id(Post, post_id) || raise(ActiveRecord::RecordNotFound.new) + end +end + +```";"# frozen_string_literal: true + +describe PollParticipationService do + let(:poll_post) { FactoryBot.create(:status_message_with_poll, public: true) } + let(:poll_answer) { poll_post.poll.poll_answers.first } + + describe ""voting on poll"" do + it ""succeeds"" do + expect(poll_service.vote(poll_post.id, poll_answer.id)).not_to be_nil + end + + it ""fails to vote twice"" do + expect(poll_service.vote(poll_post.id, poll_answer.id)).not_to be_nil + expect { poll_service.vote(poll_post.id, poll_answer.id) }.to raise_error(ActiveRecord::RecordInvalid) + end + + it ""fails with bad answer id"" do + expect { poll_service.vote(poll_post.id, -2) }.to raise_error(ActiveRecord::RecordNotFound) + end + + it ""fails with bad post id"" do + expect { poll_service.vote(-1, poll_answer.id) }.to raise_error(ActiveRecord::RecordNotFound) + end + end + + def poll_service(user=alice) + PollParticipationService.new(user) + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class ReshareService + def initialize(user=nil) + @user = user + end + + def create(post_id) + post = post_service.find!(post_id) + post = post.absolute_root if post.is_a? Reshare + user.reshare!(post) + end + + def find_for_post(post_id) + reshares = post_service.find!(post_id).reshares + user ? reshares.order(Arel.sql(""author_id = #{user.person.id} DESC"")) : reshares + end + + private + + attr_reader :user + + def post_service + @post_service ||= PostService.new(user) + end +end + +```";"# frozen_string_literal: true + +describe ReshareService do + let(:post) { alice.post(:status_message, text: ""hello"", public: true) } + + describe ""#create"" do + it ""doesn't create a reshare of my own post"" do + expect { + ReshareService.new(alice).create(post.id) + }.to raise_error RuntimeError + end + + it ""creates a reshare of a post of a contact"" do + expect { + ReshareService.new(bob).create(post.id) + }.not_to raise_error + end + + it ""attaches the reshare to the post"" do + reshare = ReshareService.new(bob).create(post.id) + expect(post.reshares.first.id).to eq(reshare.id) + end + + it ""reshares the original post when called with a reshare"" do + reshare = ReshareService.new(bob).create(post.id) + reshare2 = ReshareService.new(eve).create(reshare.id) + expect(post.reshares.map(&:id)).to include(reshare2.id) + end + + it ""fails if the post does not exist"" do + expect { + ReshareService.new(bob).create(""unknown id"") + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fails if the post is not public"" do + post = alice.post(:status_message, text: ""hello"", to: alice.aspects.first) + + expect { + ReshareService.new(bob).create(post.id) + }.to raise_error ActiveRecord::RecordInvalid + end + + it ""fails if the user already reshared the post"" do + ReshareService.new(bob).create(post.id) + expect { + ReshareService.new(bob).create(post.id) + }.to raise_error ActiveRecord::RecordInvalid + end + + it ""fails if the user already reshared the original post"" do + reshare = ReshareService.new(bob).create(post.id) + expect { + ReshareService.new(bob).create(reshare.id) + }.to raise_error ActiveRecord::RecordInvalid + end + end + + describe ""#find_for_post"" do + context ""with user"" do + it ""returns reshares for a public post"" do + reshare = ReshareService.new(bob).create(post.id) + expect(ReshareService.new(eve).find_for_post(post.id)).to include(reshare) + end + + it ""returns reshares for a visible private post"" do + post = alice.post(:status_message, text: ""hello"", to: alice.aspects.first) + expect(ReshareService.new(bob).find_for_post(post.id)).to be_empty + end + + it ""doesn't return reshares for a private post the user can not see"" do + post = alice.post(:status_message, text: ""hello"", to: alice.aspects.first) + expect { + ReshareService.new(eve).find_for_post(post.id) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""returns the user's reshare first"" do + [bob, eve].map {|user| ReshareService.new(user).create(post.id) } + + [bob, eve].each do |user| + expect( + ReshareService.new(user).find_for_post(post.id).first.author.id + ).to be user.person.id + end + end + end + + context ""without user"" do + it ""returns reshares for a public post"" do + reshare = ReshareService.new(bob).create(post.id) + expect(ReshareService.new.find_for_post(post.id)).to include(reshare) + end + + it ""doesn't return reshares a for private post"" do + post = alice.post(:status_message, text: ""hello"", to: alice.aspects.first) + expect { + ReshareService.new.find_for_post(post.id) + }.to raise_error Diaspora::NonPublic + end + end + + it ""returns all reshares of a post"" do + reshares = [bob, eve].map {|user| ReshareService.new(user).create(post.id) } + + expect(ReshareService.new.find_for_post(post.id)).to match_array(reshares) + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class PhotoService + def initialize(user=nil, deny_raw_files=true) + @user = user + @deny_raw_files = deny_raw_files + end + + def visible_photo(photo_guid) + Photo.owned_or_visible_by_user(@user).where(guid: photo_guid).first + end + + def create_from_params_and_file(base_params, uploaded_file) + photo_params = build_params(base_params) + raise RuntimeError if @deny_raw_files && !confirm_uploaded_file_settings(uploaded_file) + + photo_params[:user_file] = uploaded_file + photo = @user.build_post(:photo, photo_params) + raise RuntimeError unless photo.save + + send_messages(photo, photo_params) + update_profile_photo(photo) if photo_params[:set_profile_photo] + + photo + end + + private + + def build_params(base_params) + photo_params = base_params.permit(:pending, :set_profile_photo, aspect_ids: []) + if base_params.permit(:aspect_ids)[:aspect_ids] == ""all"" + photo_params[:aspect_ids] = @user.aspects.map(&:id) + elsif photo_params[:aspect_ids].is_a?(Hash) + photo_params[:aspect_ids] = params[:photo][:aspect_ids].values + end + photo_params + end + + def confirm_uploaded_file_settings(uploaded_file) + unless uploaded_file.is_a?(ActionDispatch::Http::UploadedFile) || uploaded_file.is_a?(Rack::Test::UploadedFile) + return false + end + return false if uploaded_file.original_filename.empty? + + return false if uploaded_file.content_type.empty? + + true + end + + def send_messages(photo, photo_params) + send_to_streams(photo, photo_params) unless photo.pending && photo.public? + + @user.dispatch_post(photo, to: photo_params[:aspect_ids]) unless photo.pending + end + + def update_profile_photo(photo) + @user.update_profile(photo: photo) + end + + def send_to_streams(photo, photo_params) + aspects = @user.aspects_from_ids(photo_params[:aspect_ids]) + @user.add_to_streams(photo, aspects) + end +end + +```";"# frozen_string_literal: true + +describe PhotoService do + before do + alice_eve_spec = alice.aspects.create(name: ""eve aspect"") + alice.share_with(eve.person, alice_eve_spec) + alice_bob_spec = alice.aspects.create(name: ""bob aspect"") + alice.share_with(bob.person, alice_bob_spec) + @alice_eve_photo = alice.post(:photo, pending: false, user_file: File.open(photo_fixture_name), + to: alice_eve_spec.id) + @alice_bob_photo = alice.post(:photo, pending: false, user_file: File.open(photo_fixture_name), + to: alice_bob_spec.id) + @alice_public_photo = alice.post(:photo, pending: false, user_file: File.open(photo_fixture_name), public: true) + @bob_photo1 = bob.post(:photo, pending: true, user_file: File.open(photo_fixture_name), public: true) + end + + describe ""visible_photo"" do + it ""returns a user's photo"" do + photo = photo_service.visible_photo(@bob_photo1.guid) + expect(photo.guid).to eq(@bob_photo1.guid) + end + + it ""returns another user's public photo"" do + photo = photo_service.visible_photo(@alice_public_photo.guid) + expect(photo.guid).to eq(@alice_public_photo.guid) + end + + it ""returns another user's shared photo"" do + photo = photo_service.visible_photo(@alice_bob_photo.guid) + expect(photo.guid).to eq(@alice_bob_photo.guid) + end + + it ""returns nil for other user's private photo"" do + photo = photo_service.visible_photo(@alice_eve_photo.guid) + expect(photo).to be_nil + end + end + + describe ""create"" do + before do + @image_file = Rack::Test::UploadedFile.new(Rails.root.join(""spec"", ""fixtures"", ""button.png"").to_s, ""image/png"") + end + + context ""succeeds"" do + it ""accepts a photo from a regular form uploaded file no parameters"" do + params = ActionController::Parameters.new + photo = photo_service.create_from_params_and_file(params, @image_file) + expect(photo).not_to be_nil + expect(photo.pending?).to be_falsey + expect(photo.public?).to be_falsey + end + + it ""honors pending"" do + params = ActionController::Parameters.new(pending: true) + photo = photo_service.create_from_params_and_file(params, @image_file) + expect(photo).not_to be_nil + expect(photo.pending?).to be_truthy + expect(photo.public?).to be_falsey + end + + it ""sets a user profile when requested"" do + original_profile_pic = bob.person.profile.image_url + params = ActionController::Parameters.new(set_profile_photo: true) + photo = photo_service.create_from_params_and_file(params, @image_file) + expect(photo).not_to be_nil + expect(bob.reload.person.profile.image_url).not_to eq(original_profile_pic) + end + + it ""has correct aspects settings for limited shared"" do + params = ActionController::Parameters.new(pending: false, aspect_ids: [bob.aspects.first.id]) + photo = photo_service.create_from_params_and_file(params, @image_file) + expect(photo).not_to be_nil + expect(photo.pending?).to be_falsey + expect(photo.public?).to be_falsey + end + + it ""allow raw file if explicitly allowing"" do + params = ActionController::Parameters.new + photo = photo_service(bob, false).create_from_params_and_file(params, uploaded_photo) + expect(photo).not_to be_nil + end + end + + context ""fails"" do + before do + @params = ActionController::Parameters.new + end + + it ""fails if given a raw file"" do + expect { + photo_service.create_from_params_and_file(@params, uploaded_photo) + }.to raise_error RuntimeError + end + + it ""file type isn't an image"" do + text_file = Rack::Test::UploadedFile.new(Rails.root.join(""README.md"").to_s, ""text/plain"") + expect { + photo_service.create_from_params_and_file(@params, text_file) + }.to raise_error CarrierWave::IntegrityError + + text_file = Rack::Test::UploadedFile.new(Rails.root.join(""README.md"").to_s, ""image/png"") + expect { + photo_service.create_from_params_and_file(@params, text_file) + }.to raise_error CarrierWave::IntegrityError + end + end + end + + def photo_service(user=bob, deny_raw_files=true) + PhotoService.new(user, deny_raw_files) + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class ConversationService + def initialize(user=nil) + @user = user + end + + def all_for_user(filter={}) + conversation_filter = {} + unless filter[:only_after].nil? + conversation_filter = \ + ""conversations.created_at >= ?"", filter[:only_after] + end + + visibility_filter = if filter[:unread] + { + person_id: @user.person_id, + unread: 1 + } + else + {person_id: @user.person_id} + end + + Conversation.where(conversation_filter) + .joins(:conversation_visibilities) + .where(conversation_visibilities: visibility_filter) + .all + end + + def build(subject, text, recipients) + person_ids = @user.contacts + .mutual + .where(person_id: recipients) + .pluck(:person_id) + + opts = { + subject: subject, + message: {text: text}, + participant_ids: person_ids + } + + @user.build_conversation(opts) + end + + def find!(conversation_guid) + conversation = Conversation.find_by!(guid: conversation_guid) + @user.conversations + .joins(:conversation_visibilities) + .where(conversation_visibilities: { + person_id: @user.person_id, + conversation_id: conversation.id + }).first! + end + + def destroy!(conversation_guid) + conversation = find!(conversation_guid) + conversation.destroy! + end + + def get_visibility(conversation_guid) + conversation = find!(conversation_guid) + ConversationVisibility.where( + person_id: @user.person.id, + conversation_id: conversation.id + ).first! + end +end + +```";"# frozen_string_literal: true + +describe ConversationService do + before do + opts = { + subject: ""conversation subject"", + message: {text: ""conversation text""}, + participant_ids: [bob.person.id] + } + @conversation = alice.build_conversation(opts) + @conversation.created_at = 2.hours.ago + @conversation.save! + end + + describe ""#all_for_user"" do + before do + opts = { + subject: ""conversation subject 2"", + message: {text: ""conversation text 2""}, + participant_ids: [bob.person.id] + } + @conversation = alice.build_conversation(opts) + @conversation.created_at = 1.hour.ago + @conversation.save! + @date = @conversation.created_at + opts = { + subject: ""conversation subject 3"", + message: {text: ""conversation text 3""}, + participant_ids: [] + } + @conversation = bob.build_conversation(opts) + @conversation.save! + end + + it ""returns all conversations"" do + expect(alice_conversation_service.all_for_user.length).to eq(2) + expect(bob_conversation_service.all_for_user.length).to eq(3) + end + + it ""returns all unread conversations"" do + @conversation.conversation_visibilities[0].unread = true + @conversation.conversation_visibilities[0].save! + conversations = bob_conversation_service.all_for_user(unread: true) + expect(conversations.length).to eq(1) + end + + it ""returns conversation after a given date"" do + conversations = bob_conversation_service.all_for_user(only_after: @date) + expect(conversations.length).to eq(2) + end + end + + describe ""#find!"" do + it ""returns the conversation, if it is the user's conversation"" do + expect(bob_conversation_service.find!(@conversation.guid)).to eq( + @conversation + ) + end + + it ""returns the conversation, if the user is recipient"" do + expect(bob_conversation_service.find!(@conversation.guid)).to eq( + @conversation + ) + end + + it ""raises RecordNotFound if the conversation cannot be found"" do + expect { + alice_conversation_service.find!(""unknown"") + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""raises RecordNotFound if the user is not recipient"" do + expect { + eve_conversation_service.find!(@conversation.guid) + }.to raise_error ActiveRecord::RecordNotFound + end + end + + describe ""#build"" do + it ""creates the conversation for given user and recipients"" do + new_conversation = alice_conversation_service.build( + ""subject test"", + ""message test"", + [bob.person.id] + ) + expect(new_conversation.subject).to eq(""subject test"") + expect(new_conversation.author_id).to eq(alice.person.id) + expect(new_conversation.messages[0].text).to eq(""message test"") + expect(new_conversation.messages[0].author_id).to eq(alice.person.id) + expect(new_conversation.participants.length).to eq(2) + end + + it ""doesn't add recipients if they are not user contacts"" do + new_conversation = alice_conversation_service.build( + ""subject test"", + ""message test"", + [bob.person.id, eve.person.id] + ) + expect(new_conversation.participants.length).to eq(2) + expect(new_conversation.messages[0].text).to eq(""message test"") + expect(new_conversation.messages[0].author_id).to eq(alice.person.id) + end + end + + describe ""#get_visibility"" do + it ""returns visibility for current user"" do + visibility = alice_conversation_service.get_visibility( + @conversation.guid + ) + expect(visibility).to_not be_nil + end + + it ""raises RecordNotFound if the user has no visibility"" do + expect { + eve_conversation_service.get_visibility(@conversation.id) + }.to raise_error ActiveRecord::RecordNotFound + end + end + + describe ""#destroy!"" do + it ""deletes the conversation, when it is the user conversation"" do + alice_conversation_service.destroy!(@conversation.guid) + expect { + alice_conversation_service.find!(@conversation.guid) + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""raises RecordNotFound if the conversation cannot be found"" do + expect { + alice_conversation_service.destroy!(""unknown"") + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""raises RecordNotFound if the user is not part of the conversation"" do + expect { + eve_conversation_service.destroy!(@conversation.guid) + }.to raise_error ActiveRecord::RecordNotFound + end + end + + def alice_conversation_service + ConversationService.new(alice) + end + + def bob_conversation_service + ConversationService.new(bob) + end + + def eve_conversation_service + ConversationService.new(eve) + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class CommentService + def initialize(user=nil) + @user = user + end + + def create(post_id, text) + post = post_service.find!(post_id) + user.comment!(post, text) + end + + def find_for_post(post_id) + post_service.find!(post_id).comments.for_a_stream + end + + def find!(id_or_guid) + Comment.find_by!(comment_key(id_or_guid) => id_or_guid) + end + + def destroy(comment_id) + comment = Comment.find(comment_id) + if user.owns?(comment) || user.owns?(comment.parent) + user.retract(comment) + true + else + false + end + end + + def destroy!(comment_guid) + comment = find!(comment_guid) + if user.owns?(comment) + user.retract(comment) + elsif user.owns?(comment.parent) + user.retract(comment) + elsif comment + raise ActiveRecord::RecordInvalid + else + raise ActiveRecord::RecordNotFound + end + end + + private + + attr_reader :user + + # We can assume a guid is at least 16 characters long as we have guids set to hex(8) since we started using them. + def comment_key(id_or_guid) + id_or_guid.to_s.length < 16 ? :id : :guid + end + + def post_service + @post_service ||= PostService.new(user) + end +end + +```";"# frozen_string_literal: true + +describe CommentService do + let(:post) { alice.post(:status_message, text: ""hello"", to: alice.aspects.first) } + + describe ""#create"" do + it ""creates a comment on my own post"" do + comment = CommentService.new(alice).create(post.id, ""hi"") + expect(comment.text).to eq(""hi"") + end + + it ""creates a comment on post of a contact"" do + comment = CommentService.new(bob).create(post.id, ""hi"") + expect(comment.text).to eq(""hi"") + end + + it ""attaches the comment to the post"" do + comment = CommentService.new(alice).create(post.id, ""hi"") + expect(post.comments.first.text).to eq(""hi"") + expect(post.comments.first.id).to eq(comment.id) + end + + it ""fail if the post does not exist"" do + expect { + CommentService.new(alice).create(""unknown id"", ""hi"") + }.to raise_error ActiveRecord::RecordNotFound + end + + it ""fail if the user can not see the post"" do + expect { + CommentService.new(eve).create(post.id, ""hi"") + }.to raise_error ActiveRecord::RecordNotFound + end + end + + describe ""#find!"" do + let(:comment) { CommentService.new(bob).create(post.id, ""hi"") } + + it ""returns comment"" do + result = CommentService.new(bob).find!(comment.guid) + expect(result.id).to eq(comment.id) + end + + it ""raises exception the comment does not exist"" do + expect { + CommentService.new(bob).find!(""unknown id"") + }.to raise_error ActiveRecord::RecordNotFound + end + end + + describe ""#destroy"" do + let(:comment) { CommentService.new(bob).create(post.id, ""hi"") } + + it ""lets the user destroy his own comment"" do + result = CommentService.new(bob).destroy(comment.id) + expect(result).to be_truthy + end + + it ""lets the parent author destroy others comment"" do + result = CommentService.new(alice).destroy(comment.id) + expect(result).to be_truthy + end + + it ""does not let someone destroy others comment"" do + result = CommentService.new(eve).destroy(comment.id) + expect(result).to be_falsey + end + + it ""fails if the comment does not exist"" do + expect { + CommentService.new(bob).destroy(""unknown id"") + }.to raise_error ActiveRecord::RecordNotFound + end + end + + describe ""#destroy!"" do + let(:comment) { CommentService.new(bob).create(post.id, ""hi"") } + + it ""lets the user destroy his own comment"" do + result = CommentService.new(bob).destroy!(comment.guid) + expect(result).to be_truthy + end + + it ""lets the parent author destroy others comment"" do + result = CommentService.new(alice).destroy!(comment.guid) + expect(result).to be_truthy + end + + it ""does not let someone destroy others comment"" do + expect { + CommentService.new(eve).destroy!(comment.guid) + }.to raise_error ActiveRecord::RecordInvalid + end + + it ""raises exception the comment does not exist"" do + expect { + CommentService.new(bob).destroy!(""unknown id"") + }.to raise_error ActiveRecord::RecordNotFound + end + end + + describe ""#find_for_post"" do + context ""with user"" do + it ""returns comments for a public post"" do + post = alice.post(:status_message, text: ""hello"", public: true) + comment = CommentService.new(alice).create(post.id, ""hi"") + expect(CommentService.new(eve).find_for_post(post.id)).to include(comment) + end + + it ""returns comments for a visible private post"" do + comment = CommentService.new(alice).create(post.id, ""hi"") + expect(CommentService.new(bob).find_for_post(post.id)).to include(comment) + end + + it ""does not return comments for private post the user can not see"" do + expect { + CommentService.new(eve).find_for_post(post.id) + }.to raise_error ActiveRecord::RecordNotFound + end + end + + context ""without user"" do + it ""returns comments for a public post"" do + post = alice.post(:status_message, text: ""hello"", public: true) + comment = CommentService.new(alice).create(post.id, ""hi"") + expect(CommentService.new.find_for_post(post.id)).to include(comment) + end + + it ""does not return comments for private post"" do + expect { + CommentService.new.find_for_post(post.id) + }.to raise_error Diaspora::NonPublic + end + end + + it ""returns all comments of a post"" do + post = alice.post(:status_message, text: ""hello"", public: true) + comments = [alice, bob, eve].map {|user| CommentService.new(user).create(post.id, ""hi"") } + + expect(CommentService.new.find_for_post(post.id)).to match_array(comments) + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +require 'csv' + +# NOTE: This is a deprecated service, only kept to not break ongoing imports +# on upgrade. See `BulkImportService` for its replacement. + +class ImportService < BaseService + ROWS_PROCESSING_LIMIT = 20_000 + + def call(import) + @import = import + @account = @import.account + + case @import.type + when 'following' + import_follows! + when 'blocking' + import_blocks! + when 'muting' + import_mutes! + when 'domain_blocking' + import_domain_blocks! + when 'bookmarks' + import_bookmarks! + end + end + + private + + def import_follows! + parse_import_data!(['Account address']) + import_relationships!('follow', 'unfollow', @account.following, ROWS_PROCESSING_LIMIT, reblogs: { header: 'Show boosts', default: true }, notify: { header: 'Notify on new posts', default: false }, languages: { header: 'Languages', default: nil }) + end + + def import_blocks! + parse_import_data!(['Account address']) + import_relationships!('block', 'unblock', @account.blocking, ROWS_PROCESSING_LIMIT) + end + + def import_mutes! + parse_import_data!(['Account address']) + import_relationships!('mute', 'unmute', @account.muting, ROWS_PROCESSING_LIMIT, notifications: { header: 'Hide notifications', default: true }) + end + + def import_domain_blocks! + parse_import_data!(['#domain']) + items = @data.take(ROWS_PROCESSING_LIMIT).map { |row| row['#domain'].strip } + + if @import.overwrite? + presence_hash = items.index_with(true) + + @account.domain_blocks.find_each do |domain_block| + if presence_hash[domain_block.domain] + items.delete(domain_block.domain) + else + @account.unblock_domain!(domain_block.domain) + end + end + end + + items.each do |domain| + @account.block_domain!(domain) + end + + AfterAccountDomainBlockWorker.push_bulk(items) do |domain| + [@account.id, domain] + end + end + + def import_relationships!(action, undo_action, overwrite_scope, limit, extra_fields = {}) + local_domain_suffix = ""@#{Rails.configuration.x.local_domain}"" + items = @data.take(limit).map { |row| [row['Account address']&.strip&.delete_suffix(local_domain_suffix), extra_fields.to_h { |key, field_settings| [key, row[field_settings[:header]]&.strip || field_settings[:default]] }] }.reject { |(id, _)| id.blank? } + + if @import.overwrite? + presence_hash = items.each_with_object({}) { |(id, extra), mapping| mapping[id] = [true, extra] } + + overwrite_scope.reorder(nil).find_each do |target_account| + if presence_hash[target_account.acct] + items.delete(target_account.acct) + extra = presence_hash[target_account.acct][1] + Import::RelationshipWorker.perform_async(@account.id, target_account.acct, action, extra.stringify_keys) + else + Import::RelationshipWorker.perform_async(@account.id, target_account.acct, undo_action) + end + end + end + + head_items = items.uniq { |acct, _| acct.split('@')[1] } + tail_items = items - head_items + + Import::RelationshipWorker.push_bulk(head_items + tail_items) do |acct, extra| + [@account.id, acct, action, extra.stringify_keys] + end + end + + def import_bookmarks! + parse_import_data!(['#uri']) + items = @data.take(ROWS_PROCESSING_LIMIT).map { |row| row['#uri'].strip } + + if @import.overwrite? + presence_hash = items.index_with(true) + + @account.bookmarks.find_each do |bookmark| + if presence_hash[bookmark.status.uri] + items.delete(bookmark.status.uri) + else + bookmark.destroy! + end + end + end + + statuses = items.filter_map do |uri| + status = ActivityPub::TagManager.instance.uri_to_resource(uri, Status) + next if status.nil? && ActivityPub::TagManager.instance.local_uri?(uri) + + status || ActivityPub::FetchRemoteStatusService.new.call(uri) + rescue HTTP::Error, OpenSSL::SSL::SSLError, Mastodon::UnexpectedResponseError + nil + rescue => e + Rails.logger.warn ""Unexpected error when importing bookmark: #{e}"" + nil + end + + account_ids = statuses.map(&:account_id) + preloaded_relations = @account.relations_map(account_ids, skip_blocking_and_muting: true) + + statuses.keep_if { |status| StatusPolicy.new(@account, status, preloaded_relations).show? } + + statuses.each do |status| + @account.bookmarks.find_or_create_by!(account: @account, status: status) + end + end + + def parse_import_data!(default_headers) + data = CSV.parse(import_data, headers: true) + data = CSV.parse(import_data, headers: default_headers) unless data.headers&.first&.strip&.include?(' ') + @data = data.compact_blank + end + + def import_data + Paperclip.io_adapters.for(@import.data).read.force_encoding(Encoding::UTF_8) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe ImportService, type: :service do + include RoutingHelper + + let!(:account) { Fabricate(:account, locked: false) } + let!(:bob) { Fabricate(:account, username: 'bob', locked: false) } + let!(:eve) { Fabricate(:account, username: 'eve', domain: 'example.com', locked: false, protocol: :activitypub, inbox_url: 'https://example.com/inbox') } + + before do + stub_request(:post, 'https://example.com/inbox').to_return(status: 200) + end + + context 'when importing old-style list of muted users' do + subject { described_class.new } + + let(:csv) { attachment_fixture('mute-imports.txt') } + + describe 'when no accounts are muted' do + let(:import) { Import.create(account: account, type: 'muting', data: csv) } + + it 'mutes the listed accounts, including notifications' do + subject.call(import) + expect(account.muting.count).to eq 2 + expect(Mute.find_by(account: account, target_account: bob).hide_notifications).to be true + end + end + + describe 'when some accounts are muted and overwrite is not set' do + let(:import) { Import.create(account: account, type: 'muting', data: csv) } + + it 'mutes the listed accounts, including notifications' do + account.mute!(bob, notifications: false) + subject.call(import) + expect(account.muting.count).to eq 2 + expect(Mute.find_by(account: account, target_account: bob).hide_notifications).to be true + end + end + + describe 'when some accounts are muted and overwrite is set' do + let(:import) { Import.create(account: account, type: 'muting', data: csv, overwrite: true) } + + it 'mutes the listed accounts, including notifications' do + account.mute!(bob, notifications: false) + subject.call(import) + expect(account.muting.count).to eq 2 + expect(Mute.find_by(account: account, target_account: bob).hide_notifications).to be true + end + end + end + + context 'when importing new-style list of muted users' do + subject { described_class.new } + + let(:csv) { attachment_fixture('new-mute-imports.txt') } + + describe 'when no accounts are muted' do + let(:import) { Import.create(account: account, type: 'muting', data: csv) } + + it 'mutes the listed accounts, respecting notifications' do + subject.call(import) + expect(account.muting.count).to eq 2 + expect(Mute.find_by(account: account, target_account: bob).hide_notifications).to be true + expect(Mute.find_by(account: account, target_account: eve).hide_notifications).to be false + end + end + + describe 'when some accounts are muted and overwrite is not set' do + let(:import) { Import.create(account: account, type: 'muting', data: csv) } + + it 'mutes the listed accounts, respecting notifications' do + account.mute!(bob, notifications: true) + subject.call(import) + expect(account.muting.count).to eq 2 + expect(Mute.find_by(account: account, target_account: bob).hide_notifications).to be true + expect(Mute.find_by(account: account, target_account: eve).hide_notifications).to be false + end + end + + describe 'when some accounts are muted and overwrite is set' do + let(:import) { Import.create(account: account, type: 'muting', data: csv, overwrite: true) } + + it 'mutes the listed accounts, respecting notifications' do + account.mute!(bob, notifications: true) + subject.call(import) + expect(account.muting.count).to eq 2 + expect(Mute.find_by(account: account, target_account: bob).hide_notifications).to be true + expect(Mute.find_by(account: account, target_account: eve).hide_notifications).to be false + end + end + end + + context 'when importing old-style list of followed users' do + subject { described_class.new } + + let(:csv) { attachment_fixture('mute-imports.txt') } + + describe 'when no accounts are followed' do + let(:import) { Import.create(account: account, type: 'following', data: csv) } + + it 'follows the listed accounts, including boosts' do + subject.call(import) + + expect(account.following.count).to eq 1 + expect(account.follow_requests.count).to eq 1 + expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true + end + end + + describe 'when some accounts are already followed and overwrite is not set' do + let(:import) { Import.create(account: account, type: 'following', data: csv) } + + it 'follows the listed accounts, including notifications' do + account.follow!(bob, reblogs: false) + subject.call(import) + expect(account.following.count).to eq 1 + expect(account.follow_requests.count).to eq 1 + expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true + end + end + + describe 'when some accounts are already followed and overwrite is set' do + let(:import) { Import.create(account: account, type: 'following', data: csv, overwrite: true) } + + it 'mutes the listed accounts, including notifications' do + account.follow!(bob, reblogs: false) + subject.call(import) + expect(account.following.count).to eq 1 + expect(account.follow_requests.count).to eq 1 + expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true + end + end + end + + context 'when importing new-style list of followed users' do + subject { described_class.new } + + let(:csv) { attachment_fixture('new-following-imports.txt') } + + describe 'when no accounts are followed' do + let(:import) { Import.create(account: account, type: 'following', data: csv) } + + it 'follows the listed accounts, respecting boosts' do + subject.call(import) + expect(account.following.count).to eq 1 + expect(account.follow_requests.count).to eq 1 + expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true + expect(FollowRequest.find_by(account: account, target_account: eve).show_reblogs).to be false + end + end + + describe 'when some accounts are already followed and overwrite is not set' do + let(:import) { Import.create(account: account, type: 'following', data: csv) } + + it 'mutes the listed accounts, respecting notifications' do + account.follow!(bob, reblogs: true) + subject.call(import) + expect(account.following.count).to eq 1 + expect(account.follow_requests.count).to eq 1 + expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true + expect(FollowRequest.find_by(account: account, target_account: eve).show_reblogs).to be false + end + end + + describe 'when some accounts are already followed and overwrite is set' do + let(:import) { Import.create(account: account, type: 'following', data: csv, overwrite: true) } + + it 'mutes the listed accounts, respecting notifications' do + account.follow!(bob, reblogs: true) + subject.call(import) + expect(account.following.count).to eq 1 + expect(account.follow_requests.count).to eq 1 + expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true + expect(FollowRequest.find_by(account: account, target_account: eve).show_reblogs).to be false + end + end + end + + # Based on the bug report 20571 where UTF-8 encoded domains were rejecting import of their users + # + # https://github.com/mastodon/mastodon/issues/20571 + context 'with a utf-8 encoded domains' do + subject { described_class.new } + + let!(:nare) { Fabricate(:account, username: 'nare', domain: 'թութ.հայ', locked: false, protocol: :activitypub, inbox_url: 'https://թութ.հայ/inbox') } + let(:csv) { attachment_fixture('utf8-followers.txt') } + let(:import) { Import.create(account: account, type: 'following', data: csv) } + + # Make sure to not actually go to the remote server + before do + stub_request(:post, 'https://թութ.հայ/inbox').to_return(status: 200) + end + + it 'follows the listed account' do + expect(account.follow_requests.count).to eq 0 + subject.call(import) + expect(account.follow_requests.count).to eq 1 + end + end + + context 'when importing bookmarks' do + subject { described_class.new } + + let(:csv) { attachment_fixture('bookmark-imports.txt') } + let(:local_account) { Fabricate(:account, username: 'foo', domain: '') } + let!(:remote_status) { Fabricate(:status, uri: 'https://example.com/statuses/1312') } + let!(:direct_status) { Fabricate(:status, uri: 'https://example.com/statuses/direct', visibility: :direct) } + + around do |example| + local_before = Rails.configuration.x.local_domain + web_before = Rails.configuration.x.web_domain + Rails.configuration.x.local_domain = 'local.com' + Rails.configuration.x.web_domain = 'local.com' + example.run + Rails.configuration.x.web_domain = web_before + Rails.configuration.x.local_domain = local_before + end + + before do + service = instance_double(ActivityPub::FetchRemoteStatusService) + allow(ActivityPub::FetchRemoteStatusService).to receive(:new).and_return(service) + allow(service).to receive(:call).with('https://unknown-remote.com/users/bar/statuses/1') do + Fabricate(:status, uri: 'https://unknown-remote.com/users/bar/statuses/1') + end + end + + describe 'when no bookmarks are set' do + let(:import) { Import.create(account: account, type: 'bookmarks', data: csv) } + + it 'adds the toots the user has access to to bookmarks' do + local_status = Fabricate(:status, account: local_account, uri: 'https://local.com/users/foo/statuses/42', id: 42, local: true) + subject.call(import) + expect(account.bookmarks.map { |bookmark| bookmark.status.id }).to include(local_status.id) + expect(account.bookmarks.map { |bookmark| bookmark.status.id }).to include(remote_status.id) + expect(account.bookmarks.map { |bookmark| bookmark.status.id }).to_not include(direct_status.id) + expect(account.bookmarks.count).to eq 3 + end + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class AuthorizeFollowService < BaseService + include Payloadable + + def call(source_account, target_account, **options) + if options[:skip_follow_request] + follow_request = FollowRequest.new(account: source_account, target_account: target_account, uri: options[:follow_request_uri]) + else + follow_request = FollowRequest.find_by!(account: source_account, target_account: target_account) + follow_request.authorize! + end + + create_notification(follow_request) if !source_account.local? && source_account.activitypub? + follow_request + end + + private + + def create_notification(follow_request) + ActivityPub::DeliveryWorker.perform_async(build_json(follow_request), follow_request.target_account_id, follow_request.account.inbox_url) + end + + def build_json(follow_request) + Oj.dump(serialize_payload(follow_request, ActivityPub::AcceptFollowSerializer)) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe AuthorizeFollowService, type: :service do + subject { described_class.new } + + let(:sender) { Fabricate(:account, username: 'alice') } + + describe 'local' do + let(:bob) { Fabricate(:account, username: 'bob') } + + before do + FollowRequest.create(account: bob, target_account: sender) + subject.call(bob, sender) + end + + it 'removes follow request' do + expect(bob.requested?(sender)).to be false + end + + it 'creates follow relation' do + expect(bob.following?(sender)).to be true + end + end + + describe 'remote ActivityPub' do + let(:bob) { Fabricate(:account, username: 'bob', domain: 'example.com', protocol: :activitypub, inbox_url: 'http://example.com/inbox') } + + before do + FollowRequest.create(account: bob, target_account: sender) + stub_request(:post, bob.inbox_url).to_return(status: 200) + subject.call(bob, sender) + end + + it 'removes follow request' do + expect(bob.requested?(sender)).to be false + end + + it 'creates follow relation' do + expect(bob.following?(sender)).to be true + end + + it 'sends an accept activity' do + expect(a_request(:post, bob.inbox_url)).to have_been_made.once + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class PrecomputeFeedService < BaseService + include Redisable + + def call(account) + FeedManager.instance.populate_home(account) + ensure + redis.del(""account:#{account.id}:regeneration"") + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe PrecomputeFeedService, type: :service do + subject { described_class.new } + + describe 'call' do + let(:account) { Fabricate(:account) } + + it 'fills a user timeline with statuses' do + account = Fabricate(:account) + status = Fabricate(:status, account: account) + + subject.call(account) + + expect(redis.zscore(FeedManager.instance.key(:home, account.id), status.id)).to be_within(0.1).of(status.id.to_f) + end + + it 'does not raise an error even if it could not find any status' do + account = Fabricate(:account) + expect { subject.call(account) }.to_not raise_error + end + + it 'filters statuses' do + account = Fabricate(:account) + muted_account = Fabricate(:account) + Fabricate(:mute, account: account, target_account: muted_account) + reblog = Fabricate(:status, account: muted_account) + Fabricate(:status, account: account, reblog: reblog) + + subject.call(account) + + expect(redis.zscore(FeedManager.instance.key(:home, account.id), reblog.id)).to be_nil + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class PostStatusService < BaseService + include Redisable + include LanguagesHelper + + MIN_SCHEDULE_OFFSET = 5.minutes.freeze + + class UnexpectedMentionsError < StandardError + attr_reader :accounts + + def initialize(message, accounts) + super(message) + @accounts = accounts + end + end + + # Post a text status update, fetch and notify remote users mentioned + # @param [Account] account Account from which to post + # @param [Hash] options + # @option [String] :text Message + # @option [Status] :thread Optional status to reply to + # @option [Boolean] :sensitive + # @option [String] :visibility + # @option [String] :spoiler_text + # @option [String] :language + # @option [String] :scheduled_at + # @option [Hash] :poll Optional poll to attach + # @option [Enumerable] :media_ids Optional array of media IDs to attach + # @option [Doorkeeper::Application] :application + # @option [String] :idempotency Optional idempotency key + # @option [Boolean] :with_rate_limit + # @option [Enumerable] :allowed_mentions Optional array of expected mentioned account IDs, raises `UnexpectedMentionsError` if unexpected accounts end up in mentions + # @return [Status] + def call(account, options = {}) + @account = account + @options = options + @text = @options[:text] || '' + @in_reply_to = @options[:thread] + + return idempotency_duplicate if idempotency_given? && idempotency_duplicate? + + validate_media! + preprocess_attributes! + + if scheduled? + schedule_status! + else + process_status! + end + + redis.setex(idempotency_key, 3_600, @status.id) if idempotency_given? + + unless scheduled? + postprocess_status! + bump_potential_friendship! + end + + @status + end + + private + + def preprocess_attributes! + @sensitive = (@options[:sensitive].nil? ? @account.user&.setting_default_sensitive : @options[:sensitive]) || @options[:spoiler_text].present? + @text = @options.delete(:spoiler_text) if @text.blank? && @options[:spoiler_text].present? + @visibility = @options[:visibility] || @account.user&.setting_default_privacy + @visibility = :unlisted if @visibility&.to_sym == :public && @account.silenced? + @scheduled_at = @options[:scheduled_at]&.to_datetime + @scheduled_at = nil if scheduled_in_the_past? + rescue ArgumentError + raise ActiveRecord::RecordInvalid + end + + def process_status! + @status = @account.statuses.new(status_attributes) + process_mentions_service.call(@status, save_records: false) + safeguard_mentions!(@status) + + # The following transaction block is needed to wrap the UPDATEs to + # the media attachments when the status is created + ApplicationRecord.transaction do + @status.save! + end + end + + def safeguard_mentions!(status) + return if @options[:allowed_mentions].nil? + + expected_account_ids = @options[:allowed_mentions].map(&:to_i) + + unexpected_accounts = status.mentions.map(&:account).to_a.reject { |mentioned_account| expected_account_ids.include?(mentioned_account.id) } + return if unexpected_accounts.empty? + + raise UnexpectedMentionsError.new('Post would be sent to unexpected accounts', unexpected_accounts) + end + + def schedule_status! + status_for_validation = @account.statuses.build(status_attributes) + + if status_for_validation.valid? + # Marking the status as destroyed is necessary to prevent the status from being + # persisted when the associated media attachments get updated when creating the + # scheduled status. + status_for_validation.destroy + + # The following transaction block is needed to wrap the UPDATEs to + # the media attachments when the scheduled status is created + + ApplicationRecord.transaction do + @status = @account.scheduled_statuses.create!(scheduled_status_attributes) + end + else + raise ActiveRecord::RecordInvalid + end + end + + def postprocess_status! + process_hashtags_service.call(@status) + Trends.tags.register(@status) + LinkCrawlWorker.perform_async(@status.id) + DistributionWorker.perform_async(@status.id) + ActivityPub::DistributionWorker.perform_async(@status.id) + PollExpirationNotifyWorker.perform_at(@status.poll.expires_at, @status.poll.id) if @status.poll + end + + def validate_media! + if @options[:media_ids].blank? || !@options[:media_ids].is_a?(Enumerable) + @media = [] + return + end + + raise Mastodon::ValidationError, I18n.t('media_attachments.validations.too_many') if @options[:media_ids].size > 4 || @options[:poll].present? + + @media = @account.media_attachments.where(status_id: nil).where(id: @options[:media_ids].take(4).map(&:to_i)) + + raise Mastodon::ValidationError, I18n.t('media_attachments.validations.images_and_video') if @media.size > 1 && @media.find(&:audio_or_video?) + raise Mastodon::ValidationError, I18n.t('media_attachments.validations.not_ready') if @media.any?(&:not_processed?) + end + + def process_mentions_service + ProcessMentionsService.new + end + + def process_hashtags_service + ProcessHashtagsService.new + end + + def scheduled? + @scheduled_at.present? + end + + def idempotency_key + ""idempotency:status:#{@account.id}:#{@options[:idempotency]}"" + end + + def idempotency_given? + @options[:idempotency].present? + end + + def idempotency_duplicate + if scheduled? + @account.schedule_statuses.find(@idempotency_duplicate) + else + @account.statuses.find(@idempotency_duplicate) + end + end + + def idempotency_duplicate? + @idempotency_duplicate = redis.get(idempotency_key) + end + + def scheduled_in_the_past? + @scheduled_at.present? && @scheduled_at <= Time.now.utc + MIN_SCHEDULE_OFFSET + end + + def bump_potential_friendship! + return if !@status.reply? || @account.id == @status.in_reply_to_account_id + + ActivityTracker.increment('activity:interactions') + return if @account.following?(@status.in_reply_to_account_id) + + PotentialFriendshipTracker.record(@account.id, @status.in_reply_to_account_id, :reply) + end + + def status_attributes + { + text: @text, + media_attachments: @media || [], + ordered_media_attachment_ids: (@options[:media_ids] || []).map(&:to_i) & @media.map(&:id), + thread: @in_reply_to, + poll_attributes: poll_attributes, + sensitive: @sensitive, + spoiler_text: @options[:spoiler_text] || '', + visibility: @visibility, + language: valid_locale_cascade(@options[:language], @account.user&.preferred_posting_language, I18n.default_locale), + application: @options[:application], + rate_limit: @options[:with_rate_limit], + }.compact + end + + def scheduled_status_attributes + { + scheduled_at: @scheduled_at, + media_attachments: @media || [], + params: scheduled_options, + } + end + + def poll_attributes + return if @options[:poll].blank? + + @options[:poll].merge(account: @account, voters_count: 0) + end + + def scheduled_options + @options.tap do |options_hash| + options_hash[:in_reply_to_id] = options_hash.delete(:thread)&.id + options_hash[:application_id] = options_hash.delete(:application)&.id + options_hash[:scheduled_at] = nil + options_hash[:idempotency] = nil + options_hash[:with_rate_limit] = false + end + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe PostStatusService, type: :service do + subject { described_class.new } + + it 'creates a new status' do + account = Fabricate(:account) + text = 'test status update' + + status = subject.call(account, text: text) + + expect(status).to be_persisted + expect(status.text).to eq text + end + + it 'creates a new response status' do + in_reply_to_status = Fabricate(:status) + account = Fabricate(:account) + text = 'test status update' + + status = subject.call(account, text: text, thread: in_reply_to_status) + + expect(status).to be_persisted + expect(status.text).to eq text + expect(status.thread).to eq in_reply_to_status + end + + context 'when scheduling a status' do + let!(:account) { Fabricate(:account) } + let!(:future) { Time.now.utc + 2.hours } + let!(:previous_status) { Fabricate(:status, account: account) } + + it 'schedules a status' do + status = subject.call(account, text: 'Hi future!', scheduled_at: future) + expect(status).to be_a ScheduledStatus + expect(status.scheduled_at).to eq future + expect(status.params['text']).to eq 'Hi future!' + end + + it 'does not immediately create a status' do + media = Fabricate(:media_attachment, account: account) + status = subject.call(account, text: 'Hi future!', media_ids: [media.id], scheduled_at: future) + + expect(status).to be_a ScheduledStatus + expect(status.scheduled_at).to eq future + expect(status.params['text']).to eq 'Hi future!' + expect(status.params['media_ids']).to eq [media.id] + expect(media.reload.status).to be_nil + expect(Status.where(text: 'Hi future!')).to_not exist + end + + it 'does not change statuses count' do + expect { subject.call(account, text: 'Hi future!', scheduled_at: future, thread: previous_status) }.to_not(change { [account.statuses_count, previous_status.replies_count] }) + end + end + + it 'creates response to the original status of boost' do + boosted_status = Fabricate(:status) + in_reply_to_status = Fabricate(:status, reblog: boosted_status) + account = Fabricate(:account) + text = 'test status update' + + status = subject.call(account, text: text, thread: in_reply_to_status) + + expect(status).to be_persisted + expect(status.text).to eq text + expect(status.thread).to eq boosted_status + end + + it 'creates a sensitive status' do + status = create_status_with_options(sensitive: true) + + expect(status).to be_persisted + expect(status).to be_sensitive + end + + it 'creates a status with spoiler text' do + spoiler_text = 'spoiler text' + + status = create_status_with_options(spoiler_text: spoiler_text) + + expect(status).to be_persisted + expect(status.spoiler_text).to eq spoiler_text + end + + it 'creates a sensitive status when there is a CW but no text' do + status = subject.call(Fabricate(:account), text: '', spoiler_text: 'foo') + + expect(status).to be_persisted + expect(status).to be_sensitive + end + + it 'creates a status with empty default spoiler text' do + status = create_status_with_options(spoiler_text: nil) + + expect(status).to be_persisted + expect(status.spoiler_text).to eq '' + end + + it 'creates a status with the given visibility' do + status = create_status_with_options(visibility: :private) + + expect(status).to be_persisted + expect(status.visibility).to eq 'private' + end + + it 'creates a status with limited visibility for silenced users' do + status = subject.call(Fabricate(:account, silenced: true), text: 'test', visibility: :public) + + expect(status).to be_persisted + expect(status.visibility).to eq 'unlisted' + end + + it 'creates a status for the given application' do + application = Fabricate(:application) + + status = create_status_with_options(application: application) + + expect(status).to be_persisted + expect(status.application).to eq application + end + + it 'creates a status with a language set' do + account = Fabricate(:account) + text = 'This is an English text.' + + status = subject.call(account, text: text) + + expect(status.language).to eq 'en' + end + + it 'processes mentions' do + mention_service = instance_double(ProcessMentionsService) + allow(mention_service).to receive(:call) + allow(ProcessMentionsService).to receive(:new).and_return(mention_service) + account = Fabricate(:account) + + status = subject.call(account, text: 'test status update') + + expect(ProcessMentionsService).to have_received(:new) + expect(mention_service).to have_received(:call).with(status, save_records: false) + end + + it 'safeguards mentions' do + account = Fabricate(:account) + mentioned_account = Fabricate(:account, username: 'alice') + unexpected_mentioned_account = Fabricate(:account, username: 'bob') + + expect do + subject.call(account, text: '@alice hm, @bob is really annoying lately', allowed_mentions: [mentioned_account.id]) + end.to raise_error(an_instance_of(PostStatusService::UnexpectedMentionsError).and(having_attributes(accounts: [unexpected_mentioned_account]))) + end + + it 'processes duplicate mentions correctly' do + account = Fabricate(:account) + Fabricate(:account, username: 'alice') + + expect do + subject.call(account, text: '@alice @alice @alice hey @alice') + end.to_not raise_error + end + + it 'processes hashtags' do + hashtags_service = instance_double(ProcessHashtagsService) + allow(hashtags_service).to receive(:call) + allow(ProcessHashtagsService).to receive(:new).and_return(hashtags_service) + account = Fabricate(:account) + + status = subject.call(account, text: 'test status update') + + expect(ProcessHashtagsService).to have_received(:new) + expect(hashtags_service).to have_received(:call).with(status) + end + + it 'gets distributed' do + allow(DistributionWorker).to receive(:perform_async) + allow(ActivityPub::DistributionWorker).to receive(:perform_async) + + account = Fabricate(:account) + + status = subject.call(account, text: 'test status update') + + expect(DistributionWorker).to have_received(:perform_async).with(status.id) + expect(ActivityPub::DistributionWorker).to have_received(:perform_async).with(status.id) + end + + it 'crawls links' do + allow(LinkCrawlWorker).to receive(:perform_async) + account = Fabricate(:account) + + status = subject.call(account, text: 'test status update') + + expect(LinkCrawlWorker).to have_received(:perform_async).with(status.id) + end + + it 'attaches the given media to the created status' do + account = Fabricate(:account) + media = Fabricate(:media_attachment, account: account) + + status = subject.call( + account, + text: 'test status update', + media_ids: [media.id] + ) + + expect(media.reload.status).to eq status + end + + it 'does not attach media from another account to the created status' do + account = Fabricate(:account) + media = Fabricate(:media_attachment, account: Fabricate(:account)) + + subject.call( + account, + text: 'test status update', + media_ids: [media.id] + ) + + expect(media.reload.status).to be_nil + end + + it 'does not allow attaching more than 4 files' do + account = Fabricate(:account) + + expect do + subject.call( + account, + text: 'test status update', + media_ids: [ + Fabricate(:media_attachment, account: account), + Fabricate(:media_attachment, account: account), + Fabricate(:media_attachment, account: account), + Fabricate(:media_attachment, account: account), + Fabricate(:media_attachment, account: account), + ].map(&:id) + ) + end.to raise_error( + Mastodon::ValidationError, + I18n.t('media_attachments.validations.too_many') + ) + end + + it 'does not allow attaching both videos and images' do + account = Fabricate(:account) + video = Fabricate(:media_attachment, type: :video, account: account) + image = Fabricate(:media_attachment, type: :image, account: account) + + video.update(type: :video) + + expect do + subject.call( + account, + text: 'test status update', + media_ids: [ + video, + image, + ].map(&:id) + ) + end.to raise_error( + Mastodon::ValidationError, + I18n.t('media_attachments.validations.images_and_video') + ) + end + + it 'returns existing status when used twice with idempotency key' do + account = Fabricate(:account) + status1 = subject.call(account, text: 'test', idempotency: 'meepmeep') + status2 = subject.call(account, text: 'test', idempotency: 'meepmeep') + expect(status2.id).to eq status1.id + end + + def create_status_with_options(**options) + subject.call(Fabricate(:account), options.merge(text: 'test')) + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class AccountSearchService < BaseService + attr_reader :query, :limit, :offset, :options, :account + + MENTION_ONLY_RE = /\A#{Account::MENTION_RE}\z/i + + # Min. number of characters to look for non-exact matches + MIN_QUERY_LENGTH = 5 + + class QueryBuilder + def initialize(query, account, options = {}) + @query = query + @account = account + @options = options + end + + def build + AccountsIndex.query( + bool: { + must: { + function_score: { + query: { + bool: { + must: must_clauses, + }, + }, + + functions: [ + reputation_score_function, + followers_score_function, + time_distance_function, + ], + }, + }, + + should: should_clauses, + } + ) + end + + private + + def must_clauses + if @account && @options[:following] + [core_query, only_following_query] + else + [core_query] + end + end + + def should_clauses + if @account && !@options[:following] + [boost_following_query] + else + [] + end + end + + # This function limits results to only the accounts the user is following + def only_following_query + { + terms: { + id: following_ids, + }, + } + end + + # This function promotes accounts the user is following + def boost_following_query + { + terms: { + id: following_ids, + boost: 100, + }, + } + end + + # This function deranks accounts that follow more people than follow them + def reputation_score_function + { + script_score: { + script: { + source: ""(Math.max(doc['followers_count'].value, 0) + 0.0) / (Math.max(doc['followers_count'].value, 0) + Math.max(doc['following_count'].value, 0) + 1)"", + }, + }, + } + end + + # This function promotes accounts that have more followers + def followers_score_function + { + script_score: { + script: { + source: ""(Math.max(doc['followers_count'].value, 0) / (Math.max(doc['followers_count'].value, 0) + 1))"", + }, + }, + } + end + + # This function deranks accounts that haven't posted in a long time + def time_distance_function + { + gauss: { + last_status_at: { + scale: '30d', + offset: '30d', + decay: 0.3, + }, + }, + } + end + + def following_ids + @following_ids ||= @account.active_relationships.pluck(:target_account_id) + [@account.id] + end + end + + class AutocompleteQueryBuilder < QueryBuilder + private + + def core_query + { + multi_match: { + query: @query, + type: 'bool_prefix', + fields: %w(username^2 username.*^2 display_name display_name.*), + }, + } + end + end + + class FullQueryBuilder < QueryBuilder + private + + def core_query + { + multi_match: { + query: @query, + type: 'most_fields', + fields: %w(username^2 display_name^2 text text.*), + operator: 'and', + }, + } + end + end + + def call(query, account = nil, options = {}) + @query = query&.strip&.gsub(/\A@/, '') + @limit = options[:limit].to_i + @offset = options[:offset].to_i + @options = options + @account = account + + search_service_results.compact.uniq + end + + private + + def search_service_results + return [] if query.blank? || limit < 1 + + [exact_match] + search_results + end + + def exact_match + return unless offset.zero? && username_complete? + + return @exact_match if defined?(@exact_match) + + match = if options[:resolve] + ResolveAccountService.new.call(query) + elsif domain_is_local? + Account.find_local(query_username) + else + Account.find_remote(query_username, query_domain) + end + + match = nil if !match.nil? && !account.nil? && options[:following] && !account.following?(match) + + @exact_match = match + end + + def search_results + return [] if limit_for_non_exact_results.zero? + + @search_results ||= begin + results = from_elasticsearch if Chewy.enabled? + results ||= from_database + results + end + end + + def from_database + if account + advanced_search_results + else + simple_search_results + end + end + + def advanced_search_results + Account.advanced_search_for(terms_for_query, account, limit: limit_for_non_exact_results, following: options[:following], offset: offset) + end + + def simple_search_results + Account.search_for(terms_for_query, limit: limit_for_non_exact_results, offset: offset) + end + + def from_elasticsearch + query_builder = begin + if options[:use_searchable_text] + FullQueryBuilder.new(terms_for_query, account, options.slice(:following)) + else + AutocompleteQueryBuilder.new(terms_for_query, account, options.slice(:following)) + end + end + + records = query_builder.build.limit(limit_for_non_exact_results).offset(offset).objects.compact + + ActiveRecord::Associations::Preloader.new(records: records, associations: :account_stat) + + records + rescue Faraday::ConnectionFailed, Parslet::ParseFailed + nil + end + + def limit_for_non_exact_results + return 0 if @account.nil? && query.size < MIN_QUERY_LENGTH + + if exact_match? + limit - 1 + else + limit + end + end + + def terms_for_query + if domain_is_local? + query_username + else + query + end + end + + def split_query_string + @split_query_string ||= query.split('@') + end + + def query_username + @query_username ||= split_query_string.first || '' + end + + def query_domain + @query_domain ||= query_without_split? ? nil : split_query_string.last + end + + def query_without_split? + split_query_string.size == 1 + end + + def domain_is_local? + @domain_is_local ||= TagManager.instance.local_domain?(query_domain) + end + + def exact_match? + exact_match.present? + end + + def username_complete? + query.include?('@') && ""@#{query}"".match?(MENTION_ONLY_RE) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +describe AccountSearchService, type: :service do + describe '#call' do + context 'with a query to ignore' do + it 'returns empty array for missing query' do + results = subject.call('', nil, limit: 10) + + expect(results).to eq [] + end + + it 'returns empty array for limit zero' do + Fabricate(:account, username: 'match') + + results = subject.call('match', nil, limit: 0) + + expect(results).to eq [] + end + end + + context 'when searching for a simple term that is not an exact match' do + it 'does not return a nil entry in the array for the exact match' do + account = Fabricate(:account, username: 'matchingusername') + results = subject.call('match', nil, limit: 5) + + expect(results).to eq [account] + end + end + + context 'when there is a local domain' do + around do |example| + before = Rails.configuration.x.local_domain + + example.run + + Rails.configuration.x.local_domain = before + end + + it 'returns exact match first' do + remote = Fabricate(:account, username: 'a', domain: 'remote', display_name: 'e') + remote_too = Fabricate(:account, username: 'b', domain: 'remote', display_name: 'e') + exact = Fabricate(:account, username: 'e') + + Rails.configuration.x.local_domain = 'example.com' + + results = subject.call('e@example.com', nil, limit: 2) + + expect(results).to eq([exact, remote]).or eq([exact, remote_too]) + end + end + + context 'when there is a domain but no exact match' do + it 'follows the remote account when resolve is true' do + service = instance_double(ResolveAccountService, call: nil) + allow(ResolveAccountService).to receive(:new).and_return(service) + + subject.call('newuser@remote.com', nil, limit: 10, resolve: true) + expect(service).to have_received(:call).with('newuser@remote.com') + end + + it 'does not follow the remote account when resolve is false' do + service = instance_double(ResolveAccountService, call: nil) + allow(ResolveAccountService).to receive(:new).and_return(service) + + subject.call('newuser@remote.com', nil, limit: 10, resolve: false) + expect(service).to_not have_received(:call) + end + end + + it 'returns the fuzzy match first, and does not return suspended exacts' do + partial = Fabricate(:account, username: 'exactness') + Fabricate(:account, username: 'exact', suspended: true) + results = subject.call('exact', nil, limit: 10) + + expect(results.size).to eq 1 + expect(results).to eq [partial] + end + + it 'does not return suspended remote accounts' do + Fabricate(:account, username: 'a', domain: 'remote', display_name: 'e', suspended: true) + results = subject.call('a@example.com', nil, limit: 2) + + expect(results.size).to eq 0 + expect(results).to eq [] + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class SoftwareUpdateCheckService < BaseService + def call + clean_outdated_updates! + return unless SoftwareUpdate.check_enabled? + + process_update_notices!(fetch_update_notices) + end + + private + + def clean_outdated_updates! + SoftwareUpdate.find_each do |software_update| + software_update.delete if Mastodon::Version.gem_version >= software_update.gem_version + rescue ArgumentError + software_update.delete + end + end + + def fetch_update_notices + Request.new(:get, ""#{api_url}?version=#{version}"").add_headers('Accept' => 'application/json', 'User-Agent' => 'Mastodon update checker').perform do |res| + return Oj.load(res.body_with_limit, mode: :strict) if res.code == 200 + end + rescue HTTP::Error, OpenSSL::SSL::SSLError, Oj::ParseError + nil + end + + def api_url + ENV.fetch('UPDATE_CHECK_URL', 'https://api.joinmastodon.org/update-check') + end + + def version + @version ||= Mastodon::Version.to_s.split('+')[0] + end + + def process_update_notices!(update_notices) + return if update_notices.blank? || update_notices['updatesAvailable'].nil? + + # Clear notices that are not listed by the update server anymore + SoftwareUpdate.where.not(version: update_notices['updatesAvailable'].pluck('version')).delete_all + + return if update_notices['updatesAvailable'].blank? + + # Check if any of the notices is new, and issue notifications + known_versions = SoftwareUpdate.where(version: update_notices['updatesAvailable'].pluck('version')).pluck(:version) + new_update_notices = update_notices['updatesAvailable'].filter { |notice| known_versions.exclude?(notice['version']) } + return if new_update_notices.blank? + + new_updates = new_update_notices.map do |notice| + SoftwareUpdate.create!(version: notice['version'], urgent: notice['urgent'], type: notice['type'], release_notes: notice['releaseNotes']) + end + + notify_devops!(new_updates) + end + + def should_notify_user?(user, urgent_version, patch_version) + case user.settings['notification_emails.software_updates'] + when 'none' + false + when 'critical' + urgent_version + when 'patch' + urgent_version || patch_version + when 'all' + true + end + end + + def notify_devops!(new_updates) + has_new_urgent_version = new_updates.any?(&:urgent?) + has_new_patch_version = new_updates.any?(&:patch_type?) + + User.those_who_can(:view_devops).includes(:account).find_each do |user| + next unless should_notify_user?(user, has_new_urgent_version, has_new_patch_version) + + if has_new_urgent_version + AdminMailer.with(recipient: user.account).new_critical_software_updates.deliver_later + else + AdminMailer.with(recipient: user.account).new_software_updates.deliver_later + end + end + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe SoftwareUpdateCheckService, type: :service do + subject { described_class.new } + + shared_examples 'when the feature is enabled' do + let(:full_update_check_url) { ""#{update_check_url}?version=#{Mastodon::Version.to_s.split('+')[0]}"" } + + let(:devops_role) { Fabricate(:user_role, name: 'DevOps', permissions: UserRole::FLAGS[:view_devops]) } + let(:owner_user) { Fabricate(:user, role: UserRole.find_by(name: 'Owner')) } + let(:old_devops_user) { Fabricate(:user) } + let(:none_user) { Fabricate(:user, role: devops_role) } + let(:patch_user) { Fabricate(:user, role: devops_role) } + let(:critical_user) { Fabricate(:user, role: devops_role) } + + around do |example| + queue_adapter = ActiveJob::Base.queue_adapter + ActiveJob::Base.queue_adapter = :test + + example.run + + ActiveJob::Base.queue_adapter = queue_adapter + end + + before do + Fabricate(:software_update, version: '3.5.0', type: 'major', urgent: false) + Fabricate(:software_update, version: '42.13.12', type: 'major', urgent: false) + + owner_user.settings.update('notification_emails.software_updates': 'all') + owner_user.save! + + old_devops_user.settings.update('notification_emails.software_updates': 'all') + old_devops_user.save! + + none_user.settings.update('notification_emails.software_updates': 'none') + none_user.save! + + patch_user.settings.update('notification_emails.software_updates': 'patch') + patch_user.save! + + critical_user.settings.update('notification_emails.software_updates': 'critical') + critical_user.save! + end + + context 'when the update server errors out' do + before do + stub_request(:get, full_update_check_url).to_return(status: 404) + end + + it 'deletes outdated update records but keeps valid update records' do + expect { subject.call }.to change { SoftwareUpdate.pluck(:version).sort }.from(['3.5.0', '42.13.12']).to(['42.13.12']) + end + end + + context 'when the server returns new versions' do + let(:server_json) do + { + updatesAvailable: [ + { + version: '4.2.1', + urgent: false, + type: 'patch', + releaseNotes: 'https://github.com/mastodon/mastodon/releases/v4.2.1', + }, + { + version: '4.3.0', + urgent: false, + type: 'minor', + releaseNotes: 'https://github.com/mastodon/mastodon/releases/v4.3.0', + }, + { + version: '5.0.0', + urgent: false, + type: 'minor', + releaseNotes: 'https://github.com/mastodon/mastodon/releases/v5.0.0', + }, + ], + } + end + + before do + stub_request(:get, full_update_check_url).to_return(body: Oj.dump(server_json)) + end + + it 'updates the list of known updates' do + expect { subject.call }.to change { SoftwareUpdate.pluck(:version).sort }.from(['3.5.0', '42.13.12']).to(['4.2.1', '4.3.0', '5.0.0']) + end + + context 'when no update is urgent' do + it 'sends e-mail notifications according to settings', :aggregate_failures do + expect { subject.call }.to have_enqueued_mail(AdminMailer, :new_software_updates) + .with(hash_including(params: { recipient: owner_user.account })).once + .and(have_enqueued_mail(AdminMailer, :new_software_updates).with(hash_including(params: { recipient: patch_user.account })).once) + .and(have_enqueued_mail.at_most(2)) + end + end + + context 'when an update is urgent' do + let(:server_json) do + { + updatesAvailable: [ + { + version: '5.0.0', + urgent: true, + type: 'minor', + releaseNotes: 'https://github.com/mastodon/mastodon/releases/v5.0.0', + }, + ], + } + end + + it 'sends e-mail notifications according to settings', :aggregate_failures do + expect { subject.call }.to have_enqueued_mail(AdminMailer, :new_critical_software_updates) + .with(hash_including(params: { recipient: owner_user.account })).once + .and(have_enqueued_mail(AdminMailer, :new_critical_software_updates).with(hash_including(params: { recipient: patch_user.account })).once) + .and(have_enqueued_mail(AdminMailer, :new_critical_software_updates).with(hash_including(params: { recipient: critical_user.account })).once) + .and(have_enqueued_mail.at_most(3)) + end + end + end + end + + context 'when update checking is disabled' do + around do |example| + ClimateControl.modify UPDATE_CHECK_URL: '' do + example.run + end + end + + before do + Fabricate(:software_update, version: '3.5.0', type: 'major', urgent: false) + end + + it 'deletes outdated update records' do + expect { subject.call }.to change(SoftwareUpdate, :count).from(1).to(0) + end + end + + context 'when using the default update checking API' do + let(:update_check_url) { 'https://api.joinmastodon.org/update-check' } + + it_behaves_like 'when the feature is enabled' + end + + context 'when using a custom update check URL' do + let(:update_check_url) { 'https://api.example.com/update_check' } + + around do |example| + ClimateControl.modify UPDATE_CHECK_URL: 'https://api.example.com/update_check' do + example.run + end + end + + it_behaves_like 'when the feature is enabled' + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class UnsuspendAccountService < BaseService + include Payloadable + + # Restores a recently-unsuspended account + # @param [Account] account Account to restore + def call(account) + @account = account + + refresh_remote_account! + + return if @account.nil? || @account.suspended? + + merge_into_home_timelines! + merge_into_list_timelines! + publish_media_attachments! + distribute_update_actor! + end + + private + + def refresh_remote_account! + return if @account.local? + + # While we had the remote account suspended, it could be that + # it got suspended on its origin, too. So, we need to refresh + # it straight away so it gets marked as remotely suspended in + # that case. + + @account.update!(last_webfingered_at: nil) + @account = ResolveAccountService.new.call(@account) + + # Worth noting that it is possible that the remote has not only + # been suspended, but deleted permanently, in which case + # @account would now be nil. + end + + def distribute_update_actor! + return unless @account.local? + + account_reach_finder = AccountReachFinder.new(@account) + + ActivityPub::DeliveryWorker.push_bulk(account_reach_finder.inboxes, limit: 1_000) do |inbox_url| + [signed_activity_json, @account.id, inbox_url] + end + end + + def merge_into_home_timelines! + @account.followers_for_local_distribution.reorder(nil).find_each do |follower| + FeedManager.instance.merge_into_home(@account, follower) + end + end + + def merge_into_list_timelines! + @account.lists_for_local_distribution.reorder(nil).find_each do |list| + FeedManager.instance.merge_into_list(@account, list) + end + end + + def publish_media_attachments! + attachment_names = MediaAttachment.attachment_definitions.keys + + @account.media_attachments.find_each do |media_attachment| + attachment_names.each do |attachment_name| + attachment = media_attachment.public_send(attachment_name) + styles = MediaAttachment::DEFAULT_STYLES | attachment.styles.keys + + next if attachment.blank? + + styles.each do |style| + case Paperclip::Attachment.default_options[:storage] + when :s3 + # Prevent useless S3 calls if ACLs are disabled + next if ENV['S3_PERMISSION'] == '' + + begin + attachment.s3_object(style).acl.put(acl: Paperclip::Attachment.default_options[:s3_permissions]) + rescue Aws::S3::Errors::NoSuchKey + Rails.logger.warn ""Tried to change acl on non-existent key #{attachment.s3_object(style).key}"" + rescue Aws::S3::Errors::NotImplemented => e + Rails.logger.error ""Error trying to change ACL on #{attachment.s3_object(style).key}: #{e.message}"" + end + when :fog, :azure + # Not supported + when :filesystem + begin + FileUtils.chmod(0o666 & ~File.umask, attachment.path(style)) unless attachment.path(style).nil? + rescue Errno::ENOENT + Rails.logger.warn ""Tried to change permission on non-existent file #{attachment.path(style)}"" + end + end + + CacheBusterWorker.perform_async(attachment.path(style)) if Rails.configuration.x.cache_buster_enabled + end + end + end + end + + def signed_activity_json + @signed_activity_json ||= Oj.dump(serialize_payload(@account, ActivityPub::UpdateSerializer, signer: @account)) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe UnsuspendAccountService, type: :service do + shared_context 'with common context' do + subject { described_class.new.call(account) } + + let!(:local_follower) { Fabricate(:user, current_sign_in_at: 1.hour.ago).account } + let!(:list) { Fabricate(:list, account: local_follower) } + + before do + allow(FeedManager.instance).to receive_messages(merge_into_home: nil, merge_into_list: nil) + + local_follower.follow!(account) + list.accounts << account + + account.unsuspend! + end + end + + describe 'unsuspending a local account' do + def match_update_actor_request(req, account) + json = JSON.parse(req.body) + actor_id = ActivityPub::TagManager.instance.uri_for(account) + json['type'] == 'Update' && json['actor'] == actor_id && json['object']['id'] == actor_id && !json['object']['suspended'] + end + + before do + stub_request(:post, 'https://alice.com/inbox').to_return(status: 201) + stub_request(:post, 'https://bob.com/inbox').to_return(status: 201) + end + + it 'does not change the “suspended” flag' do + expect { subject }.to_not change(account, :suspended?) + end + + include_examples 'with common context' do + let!(:account) { Fabricate(:account) } + let!(:remote_follower) { Fabricate(:account, uri: 'https://alice.com', inbox_url: 'https://alice.com/inbox', protocol: :activitypub, domain: 'alice.com') } + let!(:remote_reporter) { Fabricate(:account, uri: 'https://bob.com', inbox_url: 'https://bob.com/inbox', protocol: :activitypub, domain: 'bob.com') } + let!(:report) { Fabricate(:report, account: remote_reporter, target_account: account) } + + before do + remote_follower.follow!(account) + end + + it ""merges back into local followers' feeds"" do + subject + expect(FeedManager.instance).to have_received(:merge_into_home).with(account, local_follower) + expect(FeedManager.instance).to have_received(:merge_into_list).with(account, list) + end + + it 'sends an update actor to followers and reporters' do + subject + expect(a_request(:post, remote_follower.inbox_url).with { |req| match_update_actor_request(req, account) }).to have_been_made.once + expect(a_request(:post, remote_reporter.inbox_url).with { |req| match_update_actor_request(req, account) }).to have_been_made.once + end + end + end + + describe 'unsuspending a remote account' do + include_examples 'with common context' do + let!(:account) { Fabricate(:account, domain: 'bob.com', uri: 'https://bob.com', inbox_url: 'https://bob.com/inbox', protocol: :activitypub) } + let!(:resolve_account_service) { instance_double(ResolveAccountService) } + + before do + allow(ResolveAccountService).to receive(:new).and_return(resolve_account_service) + end + + context 'when the account is not remotely suspended' do + before do + allow(resolve_account_service).to receive(:call).with(account).and_return(account) + end + + it 're-fetches the account' do + subject + expect(resolve_account_service).to have_received(:call).with(account) + end + + it ""merges back into local followers' feeds"" do + subject + expect(FeedManager.instance).to have_received(:merge_into_home).with(account, local_follower) + expect(FeedManager.instance).to have_received(:merge_into_list).with(account, list) + end + + it 'does not change the “suspended” flag' do + expect { subject }.to_not change(account, :suspended?) + end + end + + context 'when the account is remotely suspended' do + before do + allow(resolve_account_service).to receive(:call).with(account) do |account| + account.suspend!(origin: :remote) + account + end + end + + it 're-fetches the account' do + subject + expect(resolve_account_service).to have_received(:call).with(account) + end + + it ""does not merge back into local followers' feeds"" do + subject + expect(FeedManager.instance).to_not have_received(:merge_into_home).with(account, local_follower) + expect(FeedManager.instance).to_not have_received(:merge_into_list).with(account, list) + end + + it 'marks account as suspended' do + expect { subject }.to change(account, :suspended?).from(false).to(true) + end + end + + context 'when the account is remotely deleted' do + before do + allow(resolve_account_service).to receive(:call).with(account).and_return(nil) + end + + it 're-fetches the account' do + subject + expect(resolve_account_service).to have_received(:call).with(account) + end + + it ""does not merge back into local followers' feeds"" do + subject + expect(FeedManager.instance).to_not have_received(:merge_into_home).with(account, local_follower) + expect(FeedManager.instance).to_not have_received(:merge_into_list).with(account, list) + end + end + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class AfterBlockDomainFromAccountService < BaseService + include Payloadable + + # This service does not create an AccountDomainBlock record, + # it's meant to be called after such a record has been created + # synchronously, to ""clean up"" + def call(account, domain) + @account = account + @domain = domain + + clear_notifications! + remove_follows! + reject_existing_followers! + reject_pending_follow_requests! + end + + private + + def remove_follows! + @account.active_relationships.where(target_account: Account.where(domain: @domain)).includes(:target_account).reorder(nil).find_each do |follow| + UnfollowService.new.call(@account, follow.target_account) + end + end + + def clear_notifications! + Notification.where(account: @account).where(from_account: Account.where(domain: @domain)).in_batches.delete_all + end + + def reject_existing_followers! + @account.passive_relationships.where(account: Account.where(domain: @domain)).includes(:account).reorder(nil).find_each do |follow| + reject_follow!(follow) + end + end + + def reject_pending_follow_requests! + FollowRequest.where(target_account: @account).where(account: Account.where(domain: @domain)).includes(:account).reorder(nil).find_each do |follow_request| + reject_follow!(follow_request) + end + end + + def reject_follow!(follow) + follow.destroy + + return unless follow.account.activitypub? + + ActivityPub::DeliveryWorker.perform_async(Oj.dump(serialize_payload(follow, ActivityPub::RejectFollowSerializer)), @account.id, follow.account.inbox_url) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe AfterBlockDomainFromAccountService, type: :service do + subject { described_class.new } + + let!(:wolf) { Fabricate(:account, username: 'wolf', domain: 'evil.org', inbox_url: 'https://evil.org/inbox', protocol: :activitypub) } + let!(:alice) { Fabricate(:account, username: 'alice') } + + before do + allow(ActivityPub::DeliveryWorker).to receive(:perform_async) + end + + it 'purge followers from blocked domain' do + wolf.follow!(alice) + subject.call(alice, 'evil.org') + expect(wolf.following?(alice)).to be false + end + + it 'sends Reject->Follow to followers from blocked domain' do + wolf.follow!(alice) + subject.call(alice, 'evil.org') + expect(ActivityPub::DeliveryWorker).to have_received(:perform_async).once + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class BlockDomainService < BaseService + attr_reader :domain_block + + def call(domain_block, update = false) + @domain_block = domain_block + process_domain_block! + process_retroactive_updates! if update + end + + private + + def process_retroactive_updates! + # If the domain block severity has been changed, undo the appropriate limitations + scope = Account.by_domain_and_subdomains(domain_block.domain) + + scope.where(silenced_at: domain_block.created_at).in_batches.update_all(silenced_at: nil) unless domain_block.silence? + scope.where(suspended_at: domain_block.created_at).in_batches.update_all(suspended_at: nil, suspension_origin: nil) unless domain_block.suspend? + end + + def process_domain_block! + if domain_block.silence? + silence_accounts! + elsif domain_block.suspend? + suspend_accounts! + end + + DomainClearMediaWorker.perform_async(domain_block.id) if domain_block.reject_media? + end + + def silence_accounts! + blocked_domain_accounts.without_silenced.in_batches.update_all(silenced_at: @domain_block.created_at) + end + + def suspend_accounts! + blocked_domain_accounts.without_suspended.in_batches.update_all(suspended_at: @domain_block.created_at, suspension_origin: :local) + + blocked_domain_accounts.where(suspended_at: @domain_block.created_at).reorder(nil).find_each do |account| + DeleteAccountService.new.call(account, reserve_username: true, suspended_at: @domain_block.created_at) + end + end + + def blocked_domain + domain_block.domain + end + + def blocked_domain_accounts + Account.by_domain_and_subdomains(blocked_domain) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BlockDomainService, type: :service do + subject { described_class.new } + + let!(:bad_account) { Fabricate(:account, username: 'badguy666', domain: 'evil.org') } + let!(:bad_status_plain) { Fabricate(:status, account: bad_account, text: 'You suck') } + let!(:bad_status_with_attachment) { Fabricate(:status, account: bad_account, text: 'Hahaha') } + let!(:bad_attachment) { Fabricate(:media_attachment, account: bad_account, status: bad_status_with_attachment, file: attachment_fixture('attachment.jpg')) } + let!(:already_banned_account) { Fabricate(:account, username: 'badguy', domain: 'evil.org', suspended: true, silenced: true) } + + describe 'for a suspension' do + before do + subject.call(DomainBlock.create!(domain: 'evil.org', severity: :suspend)) + end + + it 'creates a domain block' do + expect(DomainBlock.blocked?('evil.org')).to be true + end + + it 'removes remote accounts from that domain' do + expect(Account.find_remote('badguy666', 'evil.org').suspended?).to be true + end + + it 'records suspension date appropriately' do + expect(Account.find_remote('badguy666', 'evil.org').suspended_at).to eq DomainBlock.find_by(domain: 'evil.org').created_at + end + + it 'keeps already-banned accounts banned' do + expect(Account.find_remote('badguy', 'evil.org').suspended?).to be true + end + + it 'does not overwrite suspension date of already-banned accounts' do + expect(Account.find_remote('badguy', 'evil.org').suspended_at).to_not eq DomainBlock.find_by(domain: 'evil.org').created_at + end + + it 'removes the remote accounts\'s statuses and media attachments' do + expect { bad_status_plain.reload }.to raise_exception ActiveRecord::RecordNotFound + expect { bad_status_with_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound + expect { bad_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound + end + end + + describe 'for a silence with reject media' do + before do + subject.call(DomainBlock.create!(domain: 'evil.org', severity: :silence, reject_media: true)) + end + + it 'does not create a domain block' do + expect(DomainBlock.blocked?('evil.org')).to be false + end + + it 'silences remote accounts from that domain' do + expect(Account.find_remote('badguy666', 'evil.org').silenced?).to be true + end + + it 'records suspension date appropriately' do + expect(Account.find_remote('badguy666', 'evil.org').silenced_at).to eq DomainBlock.find_by(domain: 'evil.org').created_at + end + + it 'keeps already-banned accounts banned' do + expect(Account.find_remote('badguy', 'evil.org').silenced?).to be true + end + + it 'does not overwrite suspension date of already-banned accounts' do + expect(Account.find_remote('badguy', 'evil.org').silenced_at).to_not eq DomainBlock.find_by(domain: 'evil.org').created_at + end + + it 'leaves the domains status and attachments, but clears media' do + expect { bad_status_plain.reload }.to_not raise_error + expect { bad_status_with_attachment.reload }.to_not raise_error + expect { bad_attachment.reload }.to_not raise_error + expect(bad_attachment.file.exists?).to be false + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class BlockService < BaseService + include Payloadable + + def call(account, target_account) + return if account.id == target_account.id + + UnfollowService.new.call(account, target_account) if account.following?(target_account) + UnfollowService.new.call(target_account, account) if target_account.following?(account) + RejectFollowService.new.call(target_account, account) if target_account.requested?(account) + + block = account.block!(target_account) + + BlockWorker.perform_async(account.id, target_account.id) + create_notification(block) if !target_account.local? && target_account.activitypub? + block + end + + private + + def create_notification(block) + ActivityPub::DeliveryWorker.perform_async(build_json(block), block.account_id, block.target_account.inbox_url) + end + + def build_json(block) + Oj.dump(serialize_payload(block, ActivityPub::BlockSerializer)) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BlockService, type: :service do + subject { described_class.new } + + let(:sender) { Fabricate(:account, username: 'alice') } + + describe 'local' do + let(:bob) { Fabricate(:account, username: 'bob') } + + before do + subject.call(sender, bob) + end + + it 'creates a blocking relation' do + expect(sender.blocking?(bob)).to be true + end + end + + describe 'remote ActivityPub' do + let(:bob) { Fabricate(:account, username: 'bob', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') } + + before do + stub_request(:post, 'http://example.com/inbox').to_return(status: 200) + subject.call(sender, bob) + end + + it 'creates a blocking relation' do + expect(sender.blocking?(bob)).to be true + end + + it 'sends a block activity' do + expect(a_request(:post, 'http://example.com/inbox')).to have_been_made.once + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class UnfollowService < BaseService + include Payloadable + include Redisable + include Lockable + + # Unfollow and notify the remote user + # @param [Account] source_account Where to unfollow from + # @param [Account] target_account Which to unfollow + # @param [Hash] options + # @option [Boolean] :skip_unmerge + def call(source_account, target_account, options = {}) + @source_account = source_account + @target_account = target_account + @options = options + + with_redis_lock(""relationship:#{[source_account.id, target_account.id].sort.join(':')}"") do + unfollow! || undo_follow_request! + end + end + + private + + def unfollow! + follow = Follow.find_by(account: @source_account, target_account: @target_account) + + return unless follow + + follow.destroy! + + create_notification(follow) if !@target_account.local? && @target_account.activitypub? + create_reject_notification(follow) if @target_account.local? && !@source_account.local? && @source_account.activitypub? + UnmergeWorker.perform_async(@target_account.id, @source_account.id) unless @options[:skip_unmerge] + + follow + end + + def undo_follow_request! + follow_request = FollowRequest.find_by(account: @source_account, target_account: @target_account) + + return unless follow_request + + follow_request.destroy! + + create_notification(follow_request) unless @target_account.local? + + follow_request + end + + def create_notification(follow) + ActivityPub::DeliveryWorker.perform_async(build_json(follow), follow.account_id, follow.target_account.inbox_url) + end + + def create_reject_notification(follow) + ActivityPub::DeliveryWorker.perform_async(build_reject_json(follow), follow.target_account_id, follow.account.inbox_url) + end + + def build_json(follow) + Oj.dump(serialize_payload(follow, ActivityPub::UndoFollowSerializer)) + end + + def build_reject_json(follow) + Oj.dump(serialize_payload(follow, ActivityPub::RejectFollowSerializer)) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe UnfollowService, type: :service do + subject { described_class.new } + + let(:sender) { Fabricate(:account, username: 'alice') } + + describe 'local' do + let(:bob) { Fabricate(:account, username: 'bob') } + + before do + sender.follow!(bob) + subject.call(sender, bob) + end + + it 'destroys the following relation' do + expect(sender.following?(bob)).to be false + end + end + + describe 'remote ActivityPub' do + let(:bob) { Fabricate(:account, username: 'bob', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') } + + before do + sender.follow!(bob) + stub_request(:post, 'http://example.com/inbox').to_return(status: 200) + subject.call(sender, bob) + end + + it 'destroys the following relation' do + expect(sender.following?(bob)).to be false + end + + it 'sends an unfollow activity' do + expect(a_request(:post, 'http://example.com/inbox')).to have_been_made.once + end + end + + describe 'remote ActivityPub (reverse)' do + let(:bob) { Fabricate(:account, username: 'bob', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') } + + before do + bob.follow!(sender) + stub_request(:post, 'http://example.com/inbox').to_return(status: 200) + subject.call(bob, sender) + end + + it 'destroys the following relation' do + expect(bob.following?(sender)).to be false + end + + it 'sends a reject activity' do + expect(a_request(:post, 'http://example.com/inbox')).to have_been_made.once + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class SuspendAccountService < BaseService + include Payloadable + + # Carry out the suspension of a recently-suspended account + # @param [Account] account Account to suspend + def call(account) + return unless account.suspended? + + @account = account + + reject_remote_follows! + distribute_update_actor! + unmerge_from_home_timelines! + unmerge_from_list_timelines! + privatize_media_attachments! + end + + private + + def reject_remote_follows! + return if @account.local? || !@account.activitypub? + + # When suspending a remote account, the account obviously doesn't + # actually become suspended on its origin server, i.e. unlike a + # locally suspended account it continues to have access to its home + # feed and other content. To prevent it from being able to continue + # to access toots it would receive because it follows local accounts, + # we have to force it to unfollow them. Unfortunately, there is no + # counterpart to this operation, i.e. you can't then force a remote + # account to re-follow you, so this part is not reversible. + + Follow.where(account: @account).find_in_batches do |follows| + ActivityPub::DeliveryWorker.push_bulk(follows) do |follow| + [Oj.dump(serialize_payload(follow, ActivityPub::RejectFollowSerializer)), follow.target_account_id, @account.inbox_url] + end + + follows.each(&:destroy) + end + end + + def distribute_update_actor! + return unless @account.local? + + account_reach_finder = AccountReachFinder.new(@account) + + ActivityPub::DeliveryWorker.push_bulk(account_reach_finder.inboxes, limit: 1_000) do |inbox_url| + [signed_activity_json, @account.id, inbox_url] + end + end + + def unmerge_from_home_timelines! + @account.followers_for_local_distribution.reorder(nil).find_each do |follower| + FeedManager.instance.unmerge_from_home(@account, follower) + end + end + + def unmerge_from_list_timelines! + @account.lists_for_local_distribution.reorder(nil).find_each do |list| + FeedManager.instance.unmerge_from_list(@account, list) + end + end + + def privatize_media_attachments! + attachment_names = MediaAttachment.attachment_definitions.keys + + @account.media_attachments.find_each do |media_attachment| + attachment_names.each do |attachment_name| + attachment = media_attachment.public_send(attachment_name) + styles = MediaAttachment::DEFAULT_STYLES | attachment.styles.keys + + next if attachment.blank? + + styles.each do |style| + case Paperclip::Attachment.default_options[:storage] + when :s3 + # Prevent useless S3 calls if ACLs are disabled + next if ENV['S3_PERMISSION'] == '' + + begin + attachment.s3_object(style).acl.put(acl: 'private') + rescue Aws::S3::Errors::NoSuchKey + Rails.logger.warn ""Tried to change acl on non-existent key #{attachment.s3_object(style).key}"" + rescue Aws::S3::Errors::NotImplemented => e + Rails.logger.error ""Error trying to change ACL on #{attachment.s3_object(style).key}: #{e.message}"" + end + when :fog, :azure + # Not supported + when :filesystem + begin + FileUtils.chmod(0o600 & ~File.umask, attachment.path(style)) unless attachment.path(style).nil? + rescue Errno::ENOENT + Rails.logger.warn ""Tried to change permission on non-existent file #{attachment.path(style)}"" + end + end + + CacheBusterWorker.perform_async(attachment.path(style)) if Rails.configuration.x.cache_buster_enabled + end + end + end + end + + def signed_activity_json + @signed_activity_json ||= Oj.dump(serialize_payload(@account, ActivityPub::UpdateSerializer, signer: @account)) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe SuspendAccountService, type: :service do + shared_examples 'common behavior' do + subject { described_class.new.call(account) } + + let!(:local_follower) { Fabricate(:user, current_sign_in_at: 1.hour.ago).account } + let!(:list) { Fabricate(:list, account: local_follower) } + + before do + allow(FeedManager.instance).to receive_messages(unmerge_from_home: nil, unmerge_from_list: nil) + + local_follower.follow!(account) + list.accounts << account + + account.suspend! + end + + it ""unmerges from local followers' feeds"" do + subject + expect(FeedManager.instance).to have_received(:unmerge_from_home).with(account, local_follower) + expect(FeedManager.instance).to have_received(:unmerge_from_list).with(account, list) + end + + it 'does not change the “suspended” flag' do + expect { subject }.to_not change(account, :suspended?) + end + end + + describe 'suspending a local account' do + def match_update_actor_request(req, account) + json = JSON.parse(req.body) + actor_id = ActivityPub::TagManager.instance.uri_for(account) + json['type'] == 'Update' && json['actor'] == actor_id && json['object']['id'] == actor_id && json['object']['suspended'] + end + + before do + stub_request(:post, 'https://alice.com/inbox').to_return(status: 201) + stub_request(:post, 'https://bob.com/inbox').to_return(status: 201) + end + + include_examples 'common behavior' do + let!(:account) { Fabricate(:account) } + let!(:remote_follower) { Fabricate(:account, uri: 'https://alice.com', inbox_url: 'https://alice.com/inbox', protocol: :activitypub, domain: 'alice.com') } + let!(:remote_reporter) { Fabricate(:account, uri: 'https://bob.com', inbox_url: 'https://bob.com/inbox', protocol: :activitypub, domain: 'bob.com') } + let!(:report) { Fabricate(:report, account: remote_reporter, target_account: account) } + + before do + remote_follower.follow!(account) + end + + it 'sends an update actor to followers and reporters' do + subject + expect(a_request(:post, remote_follower.inbox_url).with { |req| match_update_actor_request(req, account) }).to have_been_made.once + expect(a_request(:post, remote_reporter.inbox_url).with { |req| match_update_actor_request(req, account) }).to have_been_made.once + end + end + end + + describe 'suspending a remote account' do + def match_reject_follow_request(req, account, followee) + json = JSON.parse(req.body) + json['type'] == 'Reject' && json['actor'] == ActivityPub::TagManager.instance.uri_for(followee) && json['object']['actor'] == account.uri + end + + before do + stub_request(:post, 'https://bob.com/inbox').to_return(status: 201) + end + + include_examples 'common behavior' do + let!(:account) { Fabricate(:account, domain: 'bob.com', uri: 'https://bob.com', inbox_url: 'https://bob.com/inbox', protocol: :activitypub) } + let!(:local_followee) { Fabricate(:account) } + + before do + account.follow!(local_followee) + end + + it 'sends a reject follow' do + subject + expect(a_request(:post, account.inbox_url).with { |req| match_reject_follow_request(req, account, local_followee) }).to have_been_made.once + end + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class BulkImportService < BaseService + def call(import) + @import = import + @account = @import.account + + case @import.type.to_sym + when :following + import_follows! + when :blocking + import_blocks! + when :muting + import_mutes! + when :domain_blocking + import_domain_blocks! + when :bookmarks + import_bookmarks! + when :lists + import_lists! + end + + @import.update!(state: :finished, finished_at: Time.now.utc) if @import.processed_items == @import.total_items + rescue + @import.update!(state: :finished, finished_at: Time.now.utc) + + raise + end + + private + + def extract_rows_by_acct + local_domain_suffix = ""@#{Rails.configuration.x.local_domain}"" + @import.rows.to_a.index_by { |row| row.data['acct'].delete_suffix(local_domain_suffix) } + end + + def import_follows! + rows_by_acct = extract_rows_by_acct + + if @import.overwrite? + @account.following.reorder(nil).find_each do |followee| + row = rows_by_acct.delete(followee.acct) + + if row.nil? + UnfollowService.new.call(@account, followee) + else + row.destroy + @import.processed_items += 1 + @import.imported_items += 1 + + # Since we're updating the settings of an existing relationship, we can safely call + # FollowService directly + FollowService.new.call(@account, followee, reblogs: row.data['show_reblogs'], notify: row.data['notify'], languages: row.data['languages']) + end + end + + # Save pending infos due to `overwrite?` handling + @import.save! + end + + Import::RowWorker.push_bulk(rows_by_acct.values) do |row| + [row.id] + end + end + + def import_blocks! + rows_by_acct = extract_rows_by_acct + + if @import.overwrite? + @account.blocking.reorder(nil).find_each do |blocked_account| + row = rows_by_acct.delete(blocked_account.acct) + + if row.nil? + UnblockService.new.call(@account, blocked_account) + else + row.destroy + @import.processed_items += 1 + @import.imported_items += 1 + BlockService.new.call(@account, blocked_account) + end + end + + # Save pending infos due to `overwrite?` handling + @import.save! + end + + Import::RowWorker.push_bulk(rows_by_acct.values) do |row| + [row.id] + end + end + + def import_mutes! + rows_by_acct = extract_rows_by_acct + + if @import.overwrite? + @account.muting.reorder(nil).find_each do |muted_account| + row = rows_by_acct.delete(muted_account.acct) + + if row.nil? + UnmuteService.new.call(@account, muted_account) + else + row.destroy + @import.processed_items += 1 + @import.imported_items += 1 + MuteService.new.call(@account, muted_account, notifications: row.data['hide_notifications']) + end + end + + # Save pending infos due to `overwrite?` handling + @import.save! + end + + Import::RowWorker.push_bulk(rows_by_acct.values) do |row| + [row.id] + end + end + + def import_domain_blocks! + domains = @import.rows.map { |row| row.data['domain'] } + + if @import.overwrite? + @account.domain_blocks.find_each do |domain_block| + domain = domains.delete(domain_block) + + @account.unblock_domain!(domain_block.domain) if domain.nil? + end + end + + @import.rows.delete_all + domains.each { |domain| @account.block_domain!(domain) } + @import.update!(processed_items: @import.total_items, imported_items: @import.total_items) + + AfterAccountDomainBlockWorker.push_bulk(domains) do |domain| + [@account.id, domain] + end + end + + def import_bookmarks! + rows_by_uri = @import.rows.index_by { |row| row.data['uri'] } + + if @import.overwrite? + @account.bookmarks.includes(:status).find_each do |bookmark| + row = rows_by_uri.delete(ActivityPub::TagManager.instance.uri_for(bookmark.status)) + + if row.nil? + bookmark.destroy! + else + row.destroy + @import.processed_items += 1 + @import.imported_items += 1 + end + end + + # Save pending infos due to `overwrite?` handling + @import.save! + end + + Import::RowWorker.push_bulk(rows_by_uri.values) do |row| + [row.id] + end + end + + def import_lists! + rows = @import.rows.to_a + included_lists = rows.map { |row| row.data['list_name'] }.uniq + + if @import.overwrite? + @account.owned_lists.where.not(title: included_lists).destroy_all + + # As list membership changes do not retroactively change timeline + # contents, simplify things by just clearing everything + @account.owned_lists.find_each do |list| + list.list_accounts.destroy_all + end + end + + included_lists.each do |title| + @account.owned_lists.find_or_create_by!(title: title) + end + + Import::RowWorker.push_bulk(rows) do |row| + [row.id] + end + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe BulkImportService do + subject { described_class.new } + + let(:account) { Fabricate(:account) } + let(:import) { Fabricate(:bulk_import, account: account, type: import_type, overwrite: overwrite, state: :in_progress, imported_items: 0, processed_items: 0) } + + before do + import.update(total_items: import.rows.count) + end + + describe '#call', :sidekiq_fake do + context 'when importing follows' do + let(:import_type) { 'following' } + let(:overwrite) { false } + + let!(:rows) do + [ + { 'acct' => 'user@foo.bar' }, + { 'acct' => 'unknown@unknown.bar' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.follow!(Fabricate(:account)) + end + + it 'does not immediately change who the account follows' do + expect { subject.call(import) }.to_not(change { account.reload.active_relationships.to_a }) + end + + it 'enqueues workers for the expected rows' do + subject.call(import) + expect(Import::RowWorker.jobs.pluck('args').flatten).to match_array(rows.map(&:id)) + end + + it 'requests to follow all the listed users once the workers have run' do + subject.call(import) + + resolve_account_service_double = instance_double(ResolveAccountService) + allow(ResolveAccountService).to receive(:new).and_return(resolve_account_service_double) + allow(resolve_account_service_double).to receive(:call).with('user@foo.bar', any_args) { Fabricate(:account, username: 'user', domain: 'foo.bar', protocol: :activitypub) } + allow(resolve_account_service_double).to receive(:call).with('unknown@unknown.bar', any_args) { Fabricate(:account, username: 'unknown', domain: 'unknown.bar', protocol: :activitypub) } + + Import::RowWorker.drain + + expect(FollowRequest.includes(:target_account).where(account: account).map { |follow_request| follow_request.target_account.acct }).to contain_exactly('user@foo.bar', 'unknown@unknown.bar') + end + end + + context 'when importing follows with overwrite' do + let(:import_type) { 'following' } + let(:overwrite) { true } + + let!(:followed) { Fabricate(:account, username: 'followed', domain: 'foo.bar', protocol: :activitypub) } + let!(:to_be_unfollowed) { Fabricate(:account, username: 'to_be_unfollowed', domain: 'foo.bar', protocol: :activitypub) } + + let!(:rows) do + [ + { 'acct' => 'followed@foo.bar', 'show_reblogs' => false, 'notify' => true, 'languages' => ['en'] }, + { 'acct' => 'user@foo.bar' }, + { 'acct' => 'unknown@unknown.bar' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.follow!(followed, reblogs: true, notify: false) + account.follow!(to_be_unfollowed) + end + + it 'unfollows user not present on list' do + subject.call(import) + expect(account.following?(to_be_unfollowed)).to be false + end + + it 'updates the existing follow relationship as expected' do + expect { subject.call(import) }.to change { Follow.where(account: account, target_account: followed).pick(:show_reblogs, :notify, :languages) }.from([true, false, nil]).to([false, true, ['en']]) + end + + it 'enqueues workers for the expected rows' do + subject.call(import) + expect(Import::RowWorker.jobs.pluck('args').flatten).to match_array(rows[1..].map(&:id)) + end + + it 'requests to follow all the expected users once the workers have run' do + subject.call(import) + + resolve_account_service_double = instance_double(ResolveAccountService) + allow(ResolveAccountService).to receive(:new).and_return(resolve_account_service_double) + allow(resolve_account_service_double).to receive(:call).with('user@foo.bar', any_args) { Fabricate(:account, username: 'user', domain: 'foo.bar', protocol: :activitypub) } + allow(resolve_account_service_double).to receive(:call).with('unknown@unknown.bar', any_args) { Fabricate(:account, username: 'unknown', domain: 'unknown.bar', protocol: :activitypub) } + + Import::RowWorker.drain + + expect(FollowRequest.includes(:target_account).where(account: account).map { |follow_request| follow_request.target_account.acct }).to contain_exactly('user@foo.bar', 'unknown@unknown.bar') + end + end + + context 'when importing blocks' do + let(:import_type) { 'blocking' } + let(:overwrite) { false } + + let!(:rows) do + [ + { 'acct' => 'user@foo.bar' }, + { 'acct' => 'unknown@unknown.bar' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.block!(Fabricate(:account, username: 'already_blocked', domain: 'remote.org')) + end + + it 'does not immediately change who the account blocks' do + expect { subject.call(import) }.to_not(change { account.reload.blocking.to_a }) + end + + it 'enqueues workers for the expected rows' do + subject.call(import) + expect(Import::RowWorker.jobs.pluck('args').flatten).to match_array(rows.map(&:id)) + end + + it 'blocks all the listed users once the workers have run' do + subject.call(import) + + resolve_account_service_double = instance_double(ResolveAccountService) + allow(ResolveAccountService).to receive(:new).and_return(resolve_account_service_double) + allow(resolve_account_service_double).to receive(:call).with('user@foo.bar', any_args) { Fabricate(:account, username: 'user', domain: 'foo.bar', protocol: :activitypub) } + allow(resolve_account_service_double).to receive(:call).with('unknown@unknown.bar', any_args) { Fabricate(:account, username: 'unknown', domain: 'unknown.bar', protocol: :activitypub) } + + Import::RowWorker.drain + + expect(account.blocking.map(&:acct)).to contain_exactly('already_blocked@remote.org', 'user@foo.bar', 'unknown@unknown.bar') + end + end + + context 'when importing blocks with overwrite' do + let(:import_type) { 'blocking' } + let(:overwrite) { true } + + let!(:blocked) { Fabricate(:account, username: 'blocked', domain: 'foo.bar', protocol: :activitypub) } + let!(:to_be_unblocked) { Fabricate(:account, username: 'to_be_unblocked', domain: 'foo.bar', protocol: :activitypub) } + + let!(:rows) do + [ + { 'acct' => 'blocked@foo.bar' }, + { 'acct' => 'user@foo.bar' }, + { 'acct' => 'unknown@unknown.bar' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.block!(blocked) + account.block!(to_be_unblocked) + end + + it 'unblocks user not present on list' do + subject.call(import) + expect(account.blocking?(to_be_unblocked)).to be false + end + + it 'enqueues workers for the expected rows' do + subject.call(import) + expect(Import::RowWorker.jobs.pluck('args').flatten).to match_array(rows[1..].map(&:id)) + end + + it 'requests to follow all the expected users once the workers have run' do + subject.call(import) + + resolve_account_service_double = instance_double(ResolveAccountService) + allow(ResolveAccountService).to receive(:new).and_return(resolve_account_service_double) + allow(resolve_account_service_double).to receive(:call).with('user@foo.bar', any_args) { Fabricate(:account, username: 'user', domain: 'foo.bar', protocol: :activitypub) } + allow(resolve_account_service_double).to receive(:call).with('unknown@unknown.bar', any_args) { Fabricate(:account, username: 'unknown', domain: 'unknown.bar', protocol: :activitypub) } + + Import::RowWorker.drain + + expect(account.blocking.map(&:acct)).to contain_exactly('blocked@foo.bar', 'user@foo.bar', 'unknown@unknown.bar') + end + end + + context 'when importing mutes' do + let(:import_type) { 'muting' } + let(:overwrite) { false } + + let!(:rows) do + [ + { 'acct' => 'user@foo.bar' }, + { 'acct' => 'unknown@unknown.bar' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.mute!(Fabricate(:account, username: 'already_muted', domain: 'remote.org')) + end + + it 'does not immediately change who the account blocks' do + expect { subject.call(import) }.to_not(change { account.reload.muting.to_a }) + end + + it 'enqueues workers for the expected rows' do + subject.call(import) + expect(Import::RowWorker.jobs.pluck('args').flatten).to match_array(rows.map(&:id)) + end + + it 'mutes all the listed users once the workers have run' do + subject.call(import) + + resolve_account_service_double = instance_double(ResolveAccountService) + allow(ResolveAccountService).to receive(:new).and_return(resolve_account_service_double) + allow(resolve_account_service_double).to receive(:call).with('user@foo.bar', any_args) { Fabricate(:account, username: 'user', domain: 'foo.bar', protocol: :activitypub) } + allow(resolve_account_service_double).to receive(:call).with('unknown@unknown.bar', any_args) { Fabricate(:account, username: 'unknown', domain: 'unknown.bar', protocol: :activitypub) } + + Import::RowWorker.drain + + expect(account.muting.map(&:acct)).to contain_exactly('already_muted@remote.org', 'user@foo.bar', 'unknown@unknown.bar') + end + end + + context 'when importing mutes with overwrite' do + let(:import_type) { 'muting' } + let(:overwrite) { true } + + let!(:muted) { Fabricate(:account, username: 'muted', domain: 'foo.bar', protocol: :activitypub) } + let!(:to_be_unmuted) { Fabricate(:account, username: 'to_be_unmuted', domain: 'foo.bar', protocol: :activitypub) } + + let!(:rows) do + [ + { 'acct' => 'muted@foo.bar', 'hide_notifications' => true }, + { 'acct' => 'user@foo.bar' }, + { 'acct' => 'unknown@unknown.bar' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.mute!(muted, notifications: false) + account.mute!(to_be_unmuted) + end + + it 'updates the existing mute as expected' do + expect { subject.call(import) }.to change { Mute.where(account: account, target_account: muted).pick(:hide_notifications) }.from(false).to(true) + end + + it 'unblocks user not present on list' do + subject.call(import) + expect(account.muting?(to_be_unmuted)).to be false + end + + it 'enqueues workers for the expected rows' do + subject.call(import) + expect(Import::RowWorker.jobs.pluck('args').flatten).to match_array(rows[1..].map(&:id)) + end + + it 'requests to follow all the expected users once the workers have run' do + subject.call(import) + + resolve_account_service_double = instance_double(ResolveAccountService) + allow(ResolveAccountService).to receive(:new).and_return(resolve_account_service_double) + allow(resolve_account_service_double).to receive(:call).with('user@foo.bar', any_args) { Fabricate(:account, username: 'user', domain: 'foo.bar', protocol: :activitypub) } + allow(resolve_account_service_double).to receive(:call).with('unknown@unknown.bar', any_args) { Fabricate(:account, username: 'unknown', domain: 'unknown.bar', protocol: :activitypub) } + + Import::RowWorker.drain + + expect(account.muting.map(&:acct)).to contain_exactly('muted@foo.bar', 'user@foo.bar', 'unknown@unknown.bar') + end + end + + context 'when importing domain blocks' do + let(:import_type) { 'domain_blocking' } + let(:overwrite) { false } + + let!(:rows) do + [ + { 'domain' => 'blocked.com' }, + { 'domain' => 'to_block.com' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.block_domain!('alreadyblocked.com') + account.block_domain!('blocked.com') + end + + it 'blocks all the new domains' do + subject.call(import) + expect(account.domain_blocks.pluck(:domain)).to contain_exactly('alreadyblocked.com', 'blocked.com', 'to_block.com') + end + + it 'marks the import as finished' do + subject.call(import) + expect(import.reload.finished?).to be true + end + end + + context 'when importing domain blocks with overwrite' do + let(:import_type) { 'domain_blocking' } + let(:overwrite) { true } + + let!(:rows) do + [ + { 'domain' => 'blocked.com' }, + { 'domain' => 'to_block.com' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.block_domain!('alreadyblocked.com') + account.block_domain!('blocked.com') + end + + it 'blocks all the new domains' do + subject.call(import) + expect(account.domain_blocks.pluck(:domain)).to contain_exactly('blocked.com', 'to_block.com') + end + + it 'marks the import as finished' do + subject.call(import) + expect(import.reload.finished?).to be true + end + end + + context 'when importing bookmarks' do + let(:import_type) { 'bookmarks' } + let(:overwrite) { false } + + let!(:already_bookmarked) { Fabricate(:status, uri: 'https://already.bookmarked/1') } + let!(:status) { Fabricate(:status, uri: 'https://foo.bar/posts/1') } + let!(:inaccessible_status) { Fabricate(:status, uri: 'https://foo.bar/posts/inaccessible', visibility: :direct) } + let!(:bookmarked) { Fabricate(:status, uri: 'https://foo.bar/posts/already-bookmarked') } + + let!(:rows) do + [ + { 'uri' => status.uri }, + { 'uri' => inaccessible_status.uri }, + { 'uri' => bookmarked.uri }, + { 'uri' => 'https://domain.unknown/foo' }, + { 'uri' => 'https://domain.unknown/private' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.bookmarks.create!(status: already_bookmarked) + account.bookmarks.create!(status: bookmarked) + end + + it 'enqueues workers for the expected rows' do + subject.call(import) + expect(Import::RowWorker.jobs.pluck('args').flatten).to match_array(rows.map(&:id)) + end + + it 'updates the bookmarks as expected once the workers have run' do + subject.call(import) + + service_double = instance_double(ActivityPub::FetchRemoteStatusService) + allow(ActivityPub::FetchRemoteStatusService).to receive(:new).and_return(service_double) + allow(service_double).to receive(:call).with('https://domain.unknown/foo') { Fabricate(:status, uri: 'https://domain.unknown/foo') } + allow(service_double).to receive(:call).with('https://domain.unknown/private') { Fabricate(:status, uri: 'https://domain.unknown/private', visibility: :direct) } + + Import::RowWorker.drain + + expect(account.bookmarks.map { |bookmark| bookmark.status.uri }).to contain_exactly(already_bookmarked.uri, status.uri, bookmarked.uri, 'https://domain.unknown/foo') + end + end + + context 'when importing bookmarks with overwrite' do + let(:import_type) { 'bookmarks' } + let(:overwrite) { true } + + let!(:already_bookmarked) { Fabricate(:status, uri: 'https://already.bookmarked/1') } + let!(:status) { Fabricate(:status, uri: 'https://foo.bar/posts/1') } + let!(:inaccessible_status) { Fabricate(:status, uri: 'https://foo.bar/posts/inaccessible', visibility: :direct) } + let!(:bookmarked) { Fabricate(:status, uri: 'https://foo.bar/posts/already-bookmarked') } + + let!(:rows) do + [ + { 'uri' => status.uri }, + { 'uri' => inaccessible_status.uri }, + { 'uri' => bookmarked.uri }, + { 'uri' => 'https://domain.unknown/foo' }, + { 'uri' => 'https://domain.unknown/private' }, + ].map { |data| import.rows.create!(data: data) } + end + + before do + account.bookmarks.create!(status: already_bookmarked) + account.bookmarks.create!(status: bookmarked) + end + + it 'enqueues workers for the expected rows' do + subject.call(import) + expect(Import::RowWorker.jobs.pluck('args').flatten).to match_array(rows.map(&:id)) + end + + it 'updates the bookmarks as expected once the workers have run' do + subject.call(import) + + service_double = instance_double(ActivityPub::FetchRemoteStatusService) + allow(ActivityPub::FetchRemoteStatusService).to receive(:new).and_return(service_double) + allow(service_double).to receive(:call).with('https://domain.unknown/foo') { Fabricate(:status, uri: 'https://domain.unknown/foo') } + allow(service_double).to receive(:call).with('https://domain.unknown/private') { Fabricate(:status, uri: 'https://domain.unknown/private', visibility: :direct) } + + Import::RowWorker.drain + + expect(account.bookmarks.map { |bookmark| bookmark.status.uri }).to contain_exactly(status.uri, bookmarked.uri, 'https://domain.unknown/foo') + end + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class AfterBlockService < BaseService + def call(account, target_account) + @account = account + @target_account = target_account + + clear_home_feed! + clear_list_feeds! + clear_notifications! + clear_conversations! + end + + private + + def clear_home_feed! + FeedManager.instance.clear_from_home(@account, @target_account) + end + + def clear_list_feeds! + FeedManager.instance.clear_from_lists(@account, @target_account) + end + + def clear_conversations! + AccountConversation.where(account: @account).where('? = ANY(participant_account_ids)', @target_account.id).in_batches.destroy_all + end + + def clear_notifications! + Notification.where(account: @account).where(from_account: @target_account).in_batches.delete_all + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe AfterBlockService, type: :service do + subject { described_class.new.call(account, target_account) } + + let(:account) { Fabricate(:account) } + let(:target_account) { Fabricate(:account) } + let(:status) { Fabricate(:status, account: target_account) } + let(:other_status) { Fabricate(:status, account: target_account) } + let(:other_account_status) { Fabricate(:status) } + let(:other_account_reblog) { Fabricate(:status, reblog_of_id: other_status.id) } + + describe 'home timeline' do + let(:home_timeline_key) { FeedManager.instance.key(:home, account.id) } + + before do + redis.del(home_timeline_key) + end + + it ""clears account's statuses"" do + FeedManager.instance.push_to_home(account, status) + FeedManager.instance.push_to_home(account, other_account_status) + FeedManager.instance.push_to_home(account, other_account_reblog) + + expect { subject }.to change { + redis.zrange(home_timeline_key, 0, -1) + }.from([status.id.to_s, other_account_status.id.to_s, other_account_reblog.id.to_s]).to([other_account_status.id.to_s]) + end + end + + describe 'lists' do + let(:list) { Fabricate(:list, account: account) } + let(:list_timeline_key) { FeedManager.instance.key(:list, list.id) } + + before do + redis.del(list_timeline_key) + end + + it ""clears account's statuses"" do + FeedManager.instance.push_to_list(list, status) + FeedManager.instance.push_to_list(list, other_account_status) + FeedManager.instance.push_to_list(list, other_account_reblog) + + expect { subject }.to change { + redis.zrange(list_timeline_key, 0, -1) + }.from([status.id.to_s, other_account_status.id.to_s, other_account_reblog.id.to_s]).to([other_account_status.id.to_s]) + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class MuteService < BaseService + def call(account, target_account, notifications: nil, duration: 0) + return if account.id == target_account.id + + mute = account.mute!(target_account, notifications: notifications, duration: duration) + + if mute.hide_notifications? + BlockWorker.perform_async(account.id, target_account.id) + else + MuteWorker.perform_async(account.id, target_account.id) + end + + DeleteMuteWorker.perform_at(duration.seconds, mute.id) if duration != 0 + + mute + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe MuteService, type: :service do + subject { described_class.new.call(account, target_account) } + + let(:account) { Fabricate(:account) } + let(:target_account) { Fabricate(:account) } + + describe 'home timeline' do + let(:status) { Fabricate(:status, account: target_account) } + let(:other_account_status) { Fabricate(:status) } + let(:home_timeline_key) { FeedManager.instance.key(:home, account.id) } + + before do + redis.del(home_timeline_key) + end + + it ""clears account's statuses"" do + FeedManager.instance.push_to_home(account, status) + FeedManager.instance.push_to_home(account, other_account_status) + + expect { subject }.to change { + redis.zrange(home_timeline_key, 0, -1) + }.from([status.id.to_s, other_account_status.id.to_s]).to([other_account_status.id.to_s]) + end + end + + it 'mutes account' do + expect { subject }.to change { + account.muting?(target_account) + }.from(false).to(true) + end + + context 'without specifying a notifications parameter' do + it 'mutes notifications from the account' do + expect { subject }.to change { + account.muting_notifications?(target_account) + }.from(false).to(true) + end + end + + context 'with a true notifications parameter' do + subject { described_class.new.call(account, target_account, notifications: true) } + + it 'mutes notifications from the account' do + expect { subject }.to change { + account.muting_notifications?(target_account) + }.from(false).to(true) + end + end + + context 'with a false notifications parameter' do + subject { described_class.new.call(account, target_account, notifications: false) } + + it 'does not mute notifications from the account' do + expect { subject }.to_not change { + account.muting_notifications?(target_account) + }.from(false) + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class RemoveFromFollowersService < BaseService + include Payloadable + + def call(source_account, target_accounts) + source_account.passive_relationships.where(account_id: target_accounts).find_each do |follow| + follow.destroy + + create_notification(follow) if source_account.local? && !follow.account.local? && follow.account.activitypub? + end + end + + private + + def create_notification(follow) + ActivityPub::DeliveryWorker.perform_async(build_json(follow), follow.target_account_id, follow.account.inbox_url) + end + + def build_json(follow) + Oj.dump(serialize_payload(follow, ActivityPub::RejectFollowSerializer)) + end +end + +```";"# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe RemoveFromFollowersService, type: :service do + subject { described_class.new } + + let(:bob) { Fabricate(:account, username: 'bob') } + + describe 'local' do + let(:sender) { Fabricate(:account, username: 'alice') } + + before do + Follow.create(account: sender, target_account: bob) + subject.call(bob, sender) + end + + it 'does not create follow relation' do + expect(bob.followed_by?(sender)).to be false + end + end + + describe 'remote ActivityPub' do + let(:sender) { Fabricate(:account, username: 'alice', domain: 'example.com', protocol: :activitypub, inbox_url: 'http://example.com/inbox') } + + before do + Follow.create(account: sender, target_account: bob) + stub_request(:post, sender.inbox_url).to_return(status: 200) + subject.call(bob, sender) + end + + it 'does not create follow relation' do + expect(bob.followed_by?(sender)).to be false + end + + it 'sends a reject activity' do + expect(a_request(:post, sender.inbox_url)).to have_been_made.once + end + end +end +" +"Write RSpec test file for following ruby class +```ruby +# frozen_string_literal: true + +class FetchLinkCardService < BaseService + include Redisable + include Lockable + + URL_PATTERN = %r{ + (#{Twitter::TwitterText::Regex[:valid_url_preceding_chars]}) # $1 preceding chars + ( # $2 URL + (https?://) # $3 Protocol (required) + (#{Twitter::TwitterText::Regex[:valid_domain]}) # $4 Domain(s) + (?::(#{Twitter::TwitterText::Regex[:valid_port_number]}))? # $5 Port number (optional) + (/#{Twitter::TwitterText::Regex[:valid_url_path]}*)? # $6 URL Path and anchor + (\?#{Twitter::TwitterText::Regex[:valid_url_query_chars]}*#{Twitter::TwitterText::Regex[:valid_url_query_ending_chars]})? # $7 Query String + ) + }iox + + def call(status) + @status = status + @original_url = parse_urls + + return if @original_url.nil? || @status.with_preview_card? + + @url = @original_url.to_s + + with_redis_lock(""fetch:#{@original_url}"") do + @card = PreviewCard.find_by(url: @url) + process_url if @card.nil? || @card.updated_at <= 2.weeks.ago || @card.missing_image? + end + + attach_card if @card&.persisted? + rescue HTTP::Error, OpenSSL::SSL::SSLError, Addressable::URI::InvalidURIError, Mastodon::HostValidationError, Mastodon::LengthValidationError => e + Rails.logger.debug { ""Error fetching link #{@original_url}: #{e}"" } + nil + end + + private + + def process_url + @card ||= PreviewCard.new(url: @url) + + attempt_oembed || attempt_opengraph + end + + def html + return @html if defined?(@html) + + @html = Request.new(:get, @url).add_headers('Accept' => 'text/html', 'User-Agent' => ""#{Mastodon::Version.user_agent} Bot"").perform do |res| + next unless res.code == 200 && res.mime_type == 'text/html' + + # We follow redirects, and ideally we want to save the preview card for + # the destination URL and not any link shortener in-between, so here + # we set the URL to the one of the last response in the redirect chain + @url = res.request.uri.to_s + @card = PreviewCard.find_or_initialize_by(url: @url) if @card.url != @url + + @html_charset = res.charset + + res.body_with_limit + end + end + + def attach_card + with_redis_lock(""attach_card:#{@status.id}"") do + return if @status.with_preview_card? + + PreviewCardsStatus.create(status: @status, preview_card: @card, url: @original_url) + Rails.cache.delete(@status) + Trends.links.register(@status) + end + end + + def parse_urls + urls = if @status.local? + @status.text.scan(URL_PATTERN).map { |array| Addressable::URI.parse(array[1]).normalize } + else + document = Nokogiri::HTML(@status.text) + links = document.css('a') + + links.filter_map { |a| Addressable::URI.parse(a['href']) unless skip_link?(a) }.filter_map(&:normalize) + end + + urls.reject { |uri| bad_url?(uri) }.first + end + + def bad_url?(uri) + # Avoid local instance URLs and invalid URLs + uri.host.blank? || TagManager.instance.local_url?(uri.to_s) || !%w(http https).include?(uri.scheme) + end + + def mention_link?(anchor) + @status.mentions.any? do |mention| + anchor['href'] == ActivityPub::TagManager.instance.url_for(mention.account) + end + end + + def skip_link?(anchor) + # Avoid links for hashtags and mentions (microformats) + anchor['rel']&.include?('tag') || anchor['class']&.match?(/u-url|h-card/) || mention_link?(anchor) + end + + def attempt_oembed + service = FetchOEmbedService.new + url_domain = Addressable::URI.parse(@url).normalized_host + cached_endpoint = Rails.cache.read(""oembed_endpoint:#{url_domain}"") + + embed = service.call(@url, cached_endpoint: cached_endpoint) unless cached_endpoint.nil? + embed ||= service.call(@url, html: html) unless html.nil? + + return false if embed.nil? + + url = Addressable::URI.parse(service.endpoint_url) + + @card.type = embed[:type] + @card.title = embed[:title] || '' + @card.author_name = embed[:author_name] || '' + @card.author_url = embed[:author_url].present? ? (url + embed[:author_url]).to_s : '' + @card.provider_name = embed[:provider_name] || '' + @card.provider_url = embed[:provider_url].present? ? (url + embed[:provider_url]).to_s : '' + @card.width = 0 + @card.height = 0 + + case @card.type + when 'link' + @card.image_remote_url = (url + embed[:thumbnail_url]).to_s if embed[:thumbnail_url].present? + when 'photo' + return false if embed[:url].blank? + + @card.embed_url = (url + embed[:url]).to_s + @card.image_remote_url = (url + embed[:url]).to_s + @card.width = embed[:width].presence || 0 + @card.height = embed[:height].presence || 0 + when 'video' + @card.width = embed[:width].presence || 0 + @card.height = embed[:height].presence || 0 + @card.html = Sanitize.fragment(embed[:html], Sanitize::Config::MASTODON_OEMBED) + @card.image_remote_url = (url + embed[:thumbnail_url]).to_s if embed[:thumbnail_url].present? + when 'rich' + # Most providers rely on